import time
import pandas as pd
import os,random,sys,codecs,datetime
from datetime import date
import configparser
import logging,easyquotation
from openpyxl import Workbook

try:
    quotation = easyquotation.use('tencent')
except:
    quotation = easyquotation.use('sina')

#记录日志到本地
def logfun(isfile):

    logger = logging.getLogger()
    # 输出到console
    # logger.setLevel(level=logging.DEBUG)
    logger.setLevel(level=logging.INFO) # 某些python库文件中有一些DEBUG级的输出信息，如果这里设置为DEBUG，会导致console和log文件中写入海量信息
    # console_formatter = colorlog.ColoredFormatter(
    #     # fmt='%(log_color)s[%(asctime)s.%(msecs)03d] %(filename)s -> %(funcName)s line:%(lineno)d [%(levelname)s] : %(message)s',
    #     fmt=' %(levelname)s: %(message)s'
    #     # datefmt='%Y-%m-%d  %H:%M:%S'
    # )
    console = logging.StreamHandler()  # 输出到console的handler
    console.setLevel(logging.INFO)
    # console.setFormatter(console_formatter)
    logger.addHandler(console)
    # 输出到文件
    if isfile:
        # 设置文件名
        now = datetime.datetime.now()
        filename = f"log_{now.strftime('%Y-%m-%d_%H-%M-%S')}.txt"
        log_path=os.path.join(os.getcwd(),'log')
        if not os.path.exists(log_path):
            os.mkdir(log_path)
        logfile = log_path + '/'+filename
        # 设置文件日志格式
        filer = logging.FileHandler(logfile,mode='w') # 输出到log文件的handler
        # filer.setLevel(level=logging.DEBUG)
        file_formatter = logging.Formatter(
            fmt='%(asctime)s - %(levelname)s: %(message)s'
        )
        # formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
        filer.setFormatter(file_formatter)
        logger.addHandler(filer)

    return logger

def check_string_contains_element(string, elements):
    return any(element in string for element in elements)

def 保存到具体表(dir,数据,sheetname):
    # 创建一个新的工作簿
    workbook = Workbook()
    # 选择默认的工作表
    worksheet = workbook.active
    # 保存工作簿
    workbook.save(dir)
    with pd.ExcelWriter(dir, mode="a") as writer:
        数据.to_excel(writer, sheet_name=sheetname, index=False)


def ReadFile(filePath):
    with codecs.open(filePath, "r") as f:
        return f.read()
def WriteFile(filePath, u, encoding="utf-8"):
    # with codecs.open(filePath,"w",encoding) as f:
    with codecs.open(filePath, "wb") as f:
        f.write(u.encode(encoding, errors="ignore"))
# def CSV_2_UTF8(src, dst):
#     content = ReadFile(src)
#     WriteFile(dst, content, encoding="utf-8")
def CSV_2_UTF8(src, dst):
    content = ReadFile(src)
    WriteFile(dst, content, encoding="utf-8")

def  每手取整(代码,数量,仓位):
    if 代码[0:2] in ["11","12"] :
        取整数量=int(round(数量*仓位,-1))  #可转债
        if 取整数量==0:
            取整数量=10
    elif 代码[0:2]=="68":
        取整数量=int(round(数量*仓位,0))   #科创板
        if 取整数量==0:
            取整数量=200
    elif 代码[0:2] in ["43","83","87"]:
        取整数量=int(round(数量*仓位,0))   #北交所
        if 取整数量==0:
            取整数量=100
    else :
        取整数量=int(round(数量*仓位,-2))
        if 取整数量==0:
            取整数量=100
    return 取整数量

#获取本地路径下的基础数据
def joinPath(fileName,subCatalog):
    pyPath=os.path.dirname(os.path.realpath(sys.argv[0]))
    if subCatalog=="":
        filePath=os.path.join(pyPath,fileName)
    else:
        pyPath=os.path.join(pyPath,subCatalog)
        if os.path.exists(pyPath):
            pass
        else:
            os.mkdir(pyPath)
        filePath=os.path.join(pyPath,fileName)
    return filePath

#  指定目录下,将数据带时间后缀保存为csv格式
def saveCsvByTime(fileNanme,saveData,TimeFlag,encondingType,subCatalog):
    # OQPath:导出目录,fileNanme：文件名前缀,saveData：保存的数据，subCatalog是否需要子目录
    now = datetime.datetime.now()
    if TimeFlag==True:
        filename = f"{fileNanme}_{now.strftime('%Y-%m-%d_%H-%M-%S')}.csv"
    else:
        filename = f"{fileNanme}.csv"
    if subCatalog=="":
        full_path = joinPath(filename,"")
    else:
        full_path = joinPath(filename,subCatalog)
    if  encondingType=="ANSI":
        saveData.to_csv(full_path,index=False,encoding="ANSI")
    else:
        saveData.to_csv(full_path,index=False)

# 获取腾讯行情的指定价格类型
def tencentQuo(OQ代码,价格类型):
    # 获取委托价格
    if ".SH" in OQ代码:
        腾讯代码="sh"+OQ代码[0:6]
    elif ".SZ" in OQ代码:
        腾讯代码="sz"+OQ代码[0:6]
    try:
        价格=quotation.real(腾讯代码)[腾讯代码[2:8]][价格类型]
    except:
        价格=0.01
    return 价格

def order_dma(dmaOrder,index):
    自然日=datetime.datetime.now().strftime("%Y%m%d")
    order_file =os.path.join(DMADir, 'algoOrder_' + 自然日 + '.csv')
    with open(order_file, 'a') as file:
        dma_order_str=toCSVFormat(dmaOrder)
        file.write(dma_order_str+"\n")   # 写入DMA文件
        print(f"已写入第{index}条，：{dma_order_str}")

def init_order_cancel_files():
    自然日=datetime.datetime.now().strftime("%Y%m%d")
    order_file =os.path.join(DMADir, 'algoOrder_' + 自然日 + '.csv')
    print(order_file)
    if not os.path.exists(order_file):
        with open(order_file,'w') as f:
            f.write("updTime,custBatchNo,acctType,acct,symbol,tradeSide,targetQty,algoId,priceType,ticks,highLimitPrice,lowLimitPrice" + "\n")
        print('创建DMA下单文件:' + order_file)

#算法单导入文件维护
def order_algo(dmaOrder,index):
    自然日=datetime.datetime.now().strftime("%Y%m%d")
    order_file =os.path.join(AlgoDir, 'algoStart_' + 自然日 + '.csv')
    with open(order_file, 'a') as file:
        dma_order_str=toCSVFormat(dmaOrder)
        file.write(dma_order_str+"\n")   # 写入算法单导入文件
        print(f"已写入第{index}条，：{dma_order_str}")

def init_algoorder_cancel_files():
    自然日=datetime.datetime.now().strftime("%Y%m%d")
    order_file =os.path.join(AlgoDir, 'algoStart_' + 自然日 + '.csv')
    print(order_file)
    if not os.path.exists(order_file):
        with open(order_file,'w') as f:
            f.write("updTime,custAlgoNo,acctType,acct,symbol,tradeSide,targetQty,targetAmt,algoId,algoParam" + "\n")
        print('创建算法单导入下单文件:' + order_file)

def toCSVFormat(order_elements):
    order_str = ",".join([str(ele) for ele in order_elements])
    return order_str


def 生成DMA价格指令(代码,方向):
    if (DMAlimit==1) & ("BJ" not in 代码):
        #启用限价报单模式
        最新价=tencentQuo(代码,"now")

        if 方向!="融券卖出":
            if DMAPriceStyle=="激进":
                ticks=random.randint(1, DMAPriceTick)*(1 if 方向=="买入" else -1)
            elif DMAPriceStyle=="中性":
                ticks=random.randint(-DMAPriceTick, DMAPriceTick)
            elif DMAPriceStyle=="被动":
                ticks=random.randint(1, DMAPriceTick)*(-1 if 方向=="买入" else 1)
        else:
            ticks=random.randint(1, DMAPriceTick)  #融券卖出被动挂单
        价格指令=[ticks,最新价,最新价]
        return 价格指令
    elif "BJ" in 代码:
        价格指令=[0,0,0]
        return 价格指令
    else:
        if 方向!="融券卖出":
            if DMAPriceStyle=="激进":
                ticks=random.randint(1, DMAPriceTick)*(1 if 方向=="买入" else -1)
            elif DMAPriceStyle=="中性":
                ticks=random.randint(-DMAPriceTick, DMAPriceTick)
            elif DMAPriceStyle=="被动":
                ticks=random.randint(1, DMAPriceTick)*(-1 if 方向=="买入" else 1)
        else:
            ticks=random.randint(1, DMAPriceTick)  #融券卖出被动挂单

        价格指令=[ticks,0,0]
        return 价格指令

def 判断时序是否一致():
    自然日=datetime.datetime.now().strftime("%Y%m%d")

    CSV_2_UTF8(os.path.join(DMADir,"algoOrder_"+自然日+".csv"), os.path.join(DMADir,"algoOrder_"+自然日+"_utf.csv"))
    CSV_2_UTF8(os.path.join(DMADir,"execResult_"+自然日+".csv"), os.path.join(DMADir,"execResult_"+自然日+"_utf.csv"))
    algoOrder =pd.read_csv(os.path.join(DMADir, 'algoOrder_' + 自然日 + '_utf.csv'))
    execResult=pd.read_csv(os.path.join(DMADir, 'execResult_' + 自然日 + '_utf.csv'))
    代码列表=list(set(algoOrder["symbol"].tolist()))
    for 代码 in 代码列表:
        代码匹配记录=algoOrder[algoOrder["symbol"]==代码]
        list_range=list(set(代码匹配记录["custBatchNo"].tolist()))
        filtered = execResult[execResult['custBatchNo'].isin(list_range) &(execResult['status']==2)]
        is_ascending = filtered['custBatchNo'].is_monotonic_increasing
        if is_ascending==False:
            log.info(f"★★★★★★代码：{代码}，algoOrder跟execResult时序存在不一致:")
            non_ascending_rows = filtered[~filtered['custBatchNo'].diff().ge(0)]
            log.info(non_ascending_rows)
    客户批号=list(set(algoOrder["custBatchNo"].tolist()))
    execResult未找到记录=0
    execResult未找到记录已发送的记录=0
    execResult未找到记录已发送成功或失败的记录=0
    execResult找到记录发送未知=0
    execResult不在白名单发送失败=0
    for 批号 in 客户批号:
        批号匹配记录=execResult[execResult["custBatchNo"]==批号]
        if len(批号匹配记录)==0:
            log.info(f"该客户批号{批号}在execResult未找到记录")
            execResult未找到记录=execResult未找到记录+1
        else:
            已发送批号匹配记录=execResult[(execResult["custBatchNo"]==批号)&(execResult["status"]==0)]
            if len(已发送批号匹配记录)==0:
                log.info(f"该客户批号{批号}在execResult未找到记录已发送的记录")
                execResult未找到记录已发送的记录=execResult未找到记录已发送的记录+1
            成功批号匹配记录=execResult[(execResult["custBatchNo"]==批号)&(execResult["status"]==2)]
            if len(成功批号匹配记录)==0:
                未找到成功但是失败=execResult[execResult["status"]==1]
                if len(未找到成功但是失败)==0:
                    log.info(f"该客户批号{批号}在execResult未找到记录已发送成功或失败的记录")
                    execResult未找到记录已发送成功或失败的记录=execResult未找到记录已发送成功或失败的记录+1
            失败批号匹配记录=execResult[(execResult["custBatchNo"]==批号)&(execResult["status"]==1)]
            if len(失败批号匹配记录)>0:
                错误原因=失败批号匹配记录['errorMsg'].iloc[-1]
                if check_string_contains_element(错误原因, DMAErrorPass)==False:
                    log.info(f"该客户批号{批号}在execResult找到记录已发送失败的记录：{错误原因}")
                    execResult不在白名单发送失败=execResult不在白名单发送失败+1
            未知批号匹配记录=execResult[(execResult["custBatchNo"]==批号)&(execResult["status"]==3)]
            if len(未知批号匹配记录)>0:
                log.info(f"该客户批号{批号}在execResult找到记录发送未知的记录")
                execResult找到记录发送未知=execResult找到记录发送未知+1
    log.info(f"algoOrder跟execResult的custBatchNo，存在{execResult未找到记录}笔记录execResult未找到custBatchNo记录，"
             f"存在{execResult未找到记录已发送的记录}笔记录execResult未找到已发送的记录，"
             f"存在{execResult未找到记录已发送成功或失败的记录}笔记录execResult未找到已发送成功或失败的记录，"
             f"存在{execResult找到记录发送未知}笔记录execResult找到记录发送未知，"
             f"存在{execResult不在白名单发送失败}笔记录execResult不在白名单发送失败，")
def 判断algo时序是否一致():
    自然日=datetime.datetime.now().strftime("%Y%m%d")

    CSV_2_UTF8(os.path.join(AlgoDir,"algoStart_"+自然日+".csv"), os.path.join(AlgoDir,"algoStart_"+自然日+"_utf.csv"))
    CSV_2_UTF8(os.path.join(AlgoDir,"algoExecStatic_"+自然日+".csv"), os.path.join(AlgoDir,"algoExecStatic_"+自然日+"_utf.csv"))
    algoOrder =pd.read_csv(os.path.join(AlgoDir, 'algoStart_' + 自然日 + '_utf.csv'))
    execResult=pd.read_csv(os.path.join(AlgoDir, 'algoExecStatic_' + 自然日 + '_utf.csv'))
    客户批号=list(set(algoOrder["custAlgoNo"].tolist()))
    execResult未找到记录=0
    execResult仅有待启动记录=0
    execResult找到已完成记录=0
    execResult找到已过期记录=0
    execResult找到错误记录=0
    for 批号 in 客户批号:
        批号匹配记录=execResult[execResult["custAlgoNo"]==批号]
        if len(批号匹配记录)==0:
            log.info(f"该客户批号{批号}在algoExecStatic未找到记录")
            execResult未找到记录=execResult未找到记录+1
        else:
            待启动批号匹配记录=execResult[(execResult["custAlgoNo"]==批号)&(execResult["status"]==1)]
            if len(待启动批号匹配记录)>0:
                仅找到待启动匹配记录=execResult[(execResult["custAlgoNo"]==批号) & ((execResult["status"]==1) | (execResult["status"]==2) | (execResult["status"]==3) | (execResult["status"]==5) | (execResult["status"]==6) | (execResult["status"]==7) | (execResult["status"]==8))]
                if len(仅找到待启动匹配记录)==0:
                    log.info(f"该客户批号{批号}在algoExecStatic仅找到待启动的记录")
                    execResult仅有待启动记录=execResult仅有待启动记录+1
            已完成匹配记录=execResult[(execResult["custAlgoNo"]==批号)&(execResult["status"]==6)]
            if len(已完成匹配记录)>0:
                execResult找到已完成记录=execResult找到已完成记录+1
            已过期匹配记录=execResult[(execResult["custAlgoNo"]==批号)&(execResult["status"]==7)]
            if len(已过期匹配记录)>0:
                execResult找到已过期记录=execResult找到已过期记录+1
            错误匹配记录=execResult[(execResult["custAlgoNo"]==批号)&(execResult["status"]==8)]
            if len(错误匹配记录)>0:
                execResult找到错误记录=execResult找到错误记录+1
    log.info(f"algoStart跟algoExecStatic的custAlgoNo，存在{execResult未找到记录}笔记录algoExecStatic未找到custAlgoNo记录，"
             f"存在{execResult仅有待启动记录}笔记录algoExecStatic仅有待启动的记录，"
             f"存在{execResult找到已完成记录}笔记录algoExecStatic算法已完成，"
             f"存在{execResult找到已过期记录}笔记录algoExecStatic算法母单已过期，"
             f"存在{execResult找到错误记录}笔记录algoExecStatic算法母单失败，")



def 统计交易下单联通性():
    自然日=datetime.datetime.now().strftime("%Y%m%d")
    CSV_2_UTF8(os.path.join(DMADir,"orderUpdate_"+自然日+".csv"), os.path.join(DMADir,"orderUpdate_"+自然日+"_utf.csv"))
    CSV_2_UTF8(os.path.join(DMADir,"tradeUpdate_"+自然日+".csv"), os.path.join(DMADir,"tradeUpdate_"+自然日+"_utf.csv"))
    orderUpdate =pd.read_csv(os.path.join(DMADir, 'orderUpdate_' + 自然日 + '_utf.csv'))
    tradeUpdate=pd.read_csv(os.path.join(DMADir, 'tradeUpdate_' + 自然日 + '_utf.csv'))

    orderUpdate["证券分类"]=orderUpdate["symbol"].str[:2].apply(lambda x:"深市主板" if x=="00"
                                        else "深市可转债" if x=="11"
                                      else "深市创业板" if x=="30"
                                        else "深市ETF基金" if x=="15"
                                      else "沪市主板" if x=="60"
                                        else "沪市可转债" if x=="12"
                                      else "沪市ETF基金" if x=="51" else "沪市ETF基金" if x=="56"  else "沪市ETF基金" if x=="58"
                                        else "沪市科创板" if x=="68"
                                        else "北交所股票" if x=="43"
                                        else "北交所股票" if x=="83"
                                        else "北交所股票" if x=="87"
                                        else "北交所股票" if x=="92"
                                       else '--')
    tradeUpdate["证券分类"]=tradeUpdate["symbol"].str[:2].apply(lambda x:"深市主板" if x=="00"
                                        else "深市可转债" if x=="11"
                                      else "深市创业板" if x=="30"
                                        else "深市ETF基金" if x=="15"
                                      else "沪市主板" if x=="60"
                                        else "沪市可转债" if x=="12"
                                      else "沪市ETF基金" if x=="51" else "沪市ETF基金" if x=="56"  else "沪市ETF基金" if x=="58"
                                        else "沪市科创板" if x=="68"
                                        else "北交所股票" if x=="43"
                                        else "北交所股票" if x=="83"
                                        else "北交所股票" if x=="87"
                                        else "北交所股票" if x=="92"
                                       else '--')

    交易下单连通性=pd.DataFrame(columns=["委托状态","账户类型","证券类型","普通买入","普通卖出","融资买入","融券卖出","卖券还款","买券还券"])
    for 委托状态 in [0,1,2,3,4,5,7,8]:
        for 账户类型 in ["UM0","UF0","AT0","UMC","ATC"]:
            for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:
                new_data=[委托状态,账户类型,证券分类,0,0,0,0,0,0]
                for 交易方向 in["1","2","A","B","C","D"]:
                    匹配委托=orderUpdate[(orderUpdate["acctType"]==账户类型) &(orderUpdate["证券分类"]==证券分类) &(orderUpdate["tradeSide"]==交易方向)&(orderUpdate["status"]==委托状态)]
                    记录数=len(匹配委托)
                    new_data[["1","2","A","B","C","D"].index(交易方向)+3]=记录数
                if 账户类型 not in ["UMC","ATC"]:
                    new_data[5],new_data[6],new_data[7],new_data[8]="NUll","NUll","NUll","NUll"
                添加记录=pd.DataFrame([new_data])
                添加记录.columns=["委托状态","账户类型","证券类型","普通买入","普通卖出","融资买入","融券卖出","卖券还款","买券还券"]
                交易下单连通性=pd.concat([交易下单连通性,添加记录])
    交易下单连通性["委托状态"]=交易下单连通性["委托状态"].apply(lambda x:"已报" if x==0
                                        else "部分成交" if x==1
                                      else "完全成交" if x==2
                                        else "部分撤单" if x==3
                                      else "全部撤单" if x==4
                                        else "订单拒绝" if x==5
                                      else "正报" if x==7
                                        else "撤销中" if x==8
                                                  else '--')
    账户类型=list(set(交易下单连通性["账户类型"].tolist()))
    for i  in 账户类型:
        数据=交易下单连通性[交易下单连通性["账户类型"]==i]
        if i not in ["UMC","ATC"]:
            数据.drop(["融资买入","融券卖出","卖券还款","买券还券"], axis=1, inplace=True)
        保存到具体表("./outPut/委托明细执行统计.xlsx",数据,str(i))
    log.info("已生成委托明细执行统计")
    交易成交连通性=pd.DataFrame(columns=["账户类型","证券类型","普通买入","普通卖出","融资买入","融券卖出","卖券还款","买券还券"])
    for 账户类型 in ["UM0","UF0","AT0","UMC","ATC"]:
         for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:
            new_data=[账户类型,证券分类,0,0,0,0,0,0]
            for 交易方向 in["1","2","A","B","C","D"]:
                匹配委托=tradeUpdate[(tradeUpdate["acctType"]==账户类型) &(tradeUpdate["证券分类"]==证券分类) &(tradeUpdate["tradeSide"]==交易方向)&(tradeUpdate["tradeType"]=="F")]
                记录数=len(匹配委托)
                new_data[["1","2","A","B","C","D"].index(交易方向)+2]=记录数
            if 账户类型 not in ["UMC","ATC"]:
                new_data[4],new_data[5],new_data[6],new_data[7]="NUll","NUll","NUll","NUll"
            添加记录=pd.DataFrame([new_data])
            添加记录.columns=["账户类型","证券类型","普通买入","普通卖出","融资买入","融券卖出","卖券还款","买券还券"]
            交易成交连通性=pd.concat([交易成交连通性,添加记录])
    saveCsvByTime("成交明细执行统计",交易成交连通性,False,"","outPut")
    log.info("已生成成交明细执行统计")



#  读取配置文件信息
pyPath=os.path.dirname(os.path.realpath(sys.argv[0]))
config = configparser.ConfigParser()
配置文件目录=os.path.join(pyPath,"testConfig")

config.read(os.path.join(配置文件目录,'testConfig.ini'),encoding='utf-8')   # 读取config.ini
maxEable=float(config.get("securityAllocation", "maxEable"))  #每笔任务按照20%可用
sloBase=int(config.get("securityAllocation", "sloBase"))   #每100只作为一个基数，融券卖出3笔，买券还券3笔
sloSellBase=int(config.get("securityAllocation", "sloSellBase"))
sloBuyBase=int(config.get("securityAllocation", "sloBuyBase"))
marginRate=float(config.get("securityAllocation", "marginRate"))
finBuyRate=float(config.get("securityAllocation", "finBuyRate"))
buyRate=float(config.get("securityAllocation", "buyRate"))
miniNum=int(config.get("securityAllocation", "miniNum"))

algoMoveUplimit=float(config.get("securityAllocation", "algoMoveUplimit"))  #调仓算法调仓比例上限
algoMoveDownlimit=float(config.get("securityAllocation", "algoMoveDownlimit"))  #调仓算法调仓比例下限
gridOrderNum=float(config.get("securityAllocation", "gridOrderNum"))    #网格交易每次交易底仓数
gridRateUpLimit=float(config.get("securityAllocation", "gridRateUpLimit"))    #网格交易每格幅度上限
gridRateDownLimit=float(config.get("securityAllocation", "gridRateDownLimit"))    #网格交易每格幅度下限
T0Max=float(config.get("securityAllocation", "T0Max"))    #T0使用的底仓数
order_mm=int(config.get("securityAllocation", "order_mm"))    #DMA算法轮询下单的间隔,毫秒
DMAPriceType=str(config.get("securityAllocation", "DMAPriceType"))    #DMA算法轮询下单使用的价格类型
DMAPriceStyle=str(config.get("securityAllocation", "DMAPriceStyle"))    #DMA算法轮询下单风格：中性、激进、被动
DMAPriceTick=int(config.get("securityAllocation", "DMAPriceTick"))    #DMA算法随机tick
DMA2=int(config.get("securityAllocation", "DMA2"))    #1生成原始DMA文件，0生成扫单测试工具格式
DMASplit=int(config.get("securityAllocation", "DMASplit"))    #是否将DMA指令拆成多笔订单，0表示不拆，N表示拆成0-N笔
DMAlimit=int(config.get("securityAllocation", "DMAlimit"))    #是否将DMA指令按限价报单
DMADir=str(config.get("securityAllocation", "DMADir"))    #DMA扫单路径
DMASellRate=float(config.get("securityAllocation", "DMASellRate"))    #DMA卖出底仓比例
DMAErrorPass=str(config.get("securityAllocation", "DMAErrorPass"))    #DMA算法需过来判断的错误原因
DMAErrorPass=DMAErrorPass.split("&")
AlgoDir=str(config.get("securityAllocation", "AlgoDir"))    #DMA扫单路径
AlgoEndTime=str(config.get("securityAllocation", "AlgoEndTime"))    #算法扫单结束时间
if config.get("outPut", "isLog")=="False":
    isLog=False
else:
    isLog=True  #打印日志推送开关
# 是否保存本地日志
log=logfun(isfile=isLog)


#随机算法结束时间
当前时间=str(datetime.datetime.now().hour)+str(datetime.datetime.now().minute)
随机算法结束时间=[]
if AlgoEndTime=="":
    if 当前时间<"1500":
        算法结束时间=["100000","103000","110000","113000","130000","133000","140000","143000","145600"]
        for i  in 算法结束时间:
            if i[0:4]>当前时间:
                随机算法结束时间.append(i)
    else :
        随机算法结束时间=[(datetime.datetime.now()+datetime.timedelta(minutes=20)).strftime("%H%M%S"),(datetime.datetime.now()+datetime.timedelta(minutes=40)).strftime("%H%M%S"),
          (datetime.datetime.now()+datetime.timedelta(minutes=60)).strftime("%H%M%S"),(datetime.datetime.now()+datetime.timedelta(minutes=80)).strftime("%H%M%S"),
          (datetime.datetime.now()+datetime.timedelta(minutes=100)).strftime("%H%M%S"),(datetime.datetime.now()+datetime.timedelta(minutes=120)).strftime("%H%M%S")]
else:
    随机算法结束时间=[AlgoEndTime]


#加载任务配置列表

log.info(f"当前执行任务的目录为：{pyPath}")

任务配置列表=pd.read_excel(os.path.join(pyPath,"自动测试任务.xls"))
任务配置列表=任务配置列表[任务配置列表["启用"]=="Y"]
任务资金账号列表=list(set(任务配置列表["账号"].tolist()))  #进行账号去重



def 预处理原始数据():
    预处理数据目录=os.path.join(pyPath,"OQData")
    # 预处理持仓数据，增加证券分类
    CSV_2_UTF8(os.path.join(预处理数据目录,"positioninfo_"+date.today().strftime("%Y%m%d")+".csv"), os.path.join(预处理数据目录,"positioninfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    CSV_2_UTF8(os.path.join(预处理数据目录,"enslo_"+date.today().strftime("%Y%m%d")+".csv"), os.path.join(预处理数据目录,"enslo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    CSV_2_UTF8(os.path.join(预处理数据目录,"compactinfo_"+date.today().strftime("%Y%m%d")+".csv"), os.path.join(预处理数据目录,"compactinfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    CSV_2_UTF8(os.path.join(预处理数据目录,"assetInfo_"+date.today().strftime("%Y%m%d")+".csv"), os.path.join(预处理数据目录,"assetInfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    持仓列表=pd.read_csv(os.path.join(预处理数据目录,"positioninfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    持仓列表.drop(持仓列表.tail(1).index,inplace=True)  #删除最后一行换行
    持仓列表["账号"]=持仓列表["账号"].astype('int64').astype('str')
    持仓列表= 持仓列表.dropna(axis=0, how='any')
    持仓列表=持仓列表[持仓列表["最新价"]!=0]
    # 预处理融券标的，融券可用头寸
    融券标的=pd.read_csv(os.path.join(预处理数据目录,"enslo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    融券标的.drop(融券标的.tail(1).index,inplace=True)
    融券标的["账号"]=融券标的["账号"].astype('int64').astype('str')
    log.info("已经预处理融券可用头寸")
    # 预处理负债合约
    融资融券合约=pd.read_csv(os.path.join(预处理数据目录,"compactinfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    融资融券合约.drop(融资融券合约.tail(1).index,inplace=True)
    融资融券合约["账号"]=融资融券合约["账号"].astype('int64').astype('str')
    log.info("已经预处理负债合约")

    # 预处理任务执行清单可用头寸列表
    执行清单=pd.DataFrame(columns=['账号','账号类型', '证券代码', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸'])
    for 资金账号 in 任务资金账号列表:
        # 资金账号=str(资金账号)
        账户类型=任务配置列表[任务配置列表["账号"]==资金账号]["账号类型"].iloc[0]

        # log.info(资金账号,账户类型)
        if 账户类型  in ["UM0","AT0","UF0"] :
            # 证券名称为空为垃圾数据，剔除掉
            #为股票账户
            资金账号持仓信息=持仓列表[(持仓列表["账号"]==str(资金账号)) & (持仓列表["可用数量"]>0)].sort_values(by="可用数量",ascending=False, inplace=False)    #只保留可用数>0的记录
            for 证券代码 in 资金账号持仓信息["securityID"]:
                持仓数量=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["当前数量"].iloc[0]
                普通卖出可用数=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["可用数量"].iloc[0]
                卖券还款可用数=0
                未还融资数量=0
                未还融券数量=0
                融券可用头寸=0
                执行指令=[资金账号,账户类型,证券代码,持仓数量,普通卖出可用数,卖券还款可用数,未还融资数量,未还融券数量,融券可用头寸]
                执行列表=pd.DataFrame([执行指令])
                执行列表.columns=['账号','账号类型', '证券代码', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸']
                执行清单=pd.concat([执行清单,执行列表])
            log.info(f"已经预处理任务执行清单可用头寸列表，账号：{str(资金账号)}，账户类型：{账户类型}")
        elif 账户类型  in ["UMC","ATC","UFC"] :
            资金账号持仓信息=持仓列表[(持仓列表["账号"]==str(资金账号)) & (持仓列表["可用数量"]>0)].sort_values(by="可用数量",ascending=False, inplace=False)

            未还融券负债=融资融券合约[(融资融券合约["账号"]==str(资金账号)) &  (融资融券合约["合约类型"]==1) & (融资融券合约["未还合约数量"]>0)].sort_values(by="未还合约数量",ascending=False, inplace=False)
            未还融资负债=融资融券合约[(融资融券合约["账号"]==str(资金账号))  & (融资融券合约["合约类型"]==0) & (融资融券合约["未还合约数量"]>0)].sort_values(by="未还合约数量",ascending=False, inplace=False)

            for 证券代码 in 资金账号持仓信息["securityID"]:

                未还融资数量=未还融资负债[(未还融资负债["账号"]==str(资金账号)) & (未还融资负债["securityID"]==证券代码)]["未还合约数量"].sum()
                未还融券数量=未还融券负债[(未还融券负债["账号"]==str(资金账号)) & (未还融券负债["securityID"]==证券代码)]["未还合约数量"].sum()
                持仓数量=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["当前数量"].iloc[0]
                卖券还款可用数=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["可用数量"].iloc[0]
                普通卖出可用数=卖券还款可用数-未还融资数量

                # 判断底仓是否存在融券可用头寸
                if 账户类型 in ["UFC","ATC"]:
                    融券可用头寸=融券标的[(融券标的["账号"]==str(资金账号)) & (融券标的["securityID"]==证券代码)]["专项可融头寸"].sum()
                elif 账户类型=="UMC":
                    融券可用头寸=融券标的[(融券标的["账号"]==str(资金账号)) & (融券标的["securityID"]==证券代码)]["普通可融头寸"].sum()
                执行指令=[资金账号,账户类型,证券代码, 持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸]
                执行列表=pd.DataFrame([执行指令])
                执行列表.columns=['账号','账号类型', '证券代码', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸']
                执行清单=pd.concat([执行清单,执行列表])
            # 没有底仓但是有融券
            融券头寸差集=list(set(融券标的["securityID"].tolist()).difference(set(资金账号持仓信息["securityID"].tolist())))
            # log.info(融券头寸差集)
            for 差集代码 in 融券头寸差集:
                if 账户类型 in ["UFC","ATC"]:
                    融券可用头寸=融券标的[(融券标的["账号"]==str(资金账号)) & (融券标的["securityID"]==差集代码)]["专项可融头寸"].sum()
                elif 账户类型=="UMC":
                    融券可用头寸=融券标的[(融券标的["账号"]==str(资金账号)) & (融券标的["securityID"]==差集代码)]["普通可融头寸"].sum()
                执行指令=[资金账号,账户类型,差集代码, 0,0, 0, 0, 0,融券可用头寸]
                执行列表=pd.DataFrame([执行指令])
                执行列表.columns=['账号','账号类型', '证券代码', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸']
                执行清单=pd.concat([执行清单,执行列表])
            log.info(f"已经预处理任务执行清单可用头寸列表，账号：{str(资金账号)}，账户类型：{账户类型}")

    # 保存预处理数据到本地
    # 增加证券分类
    执行清单["证券分类"]=执行清单["证券代码"].str[:2].apply(lambda x:"深市主板" if x=="00"
                                            else "深市可转债" if x=="11"
                                          else "深市创业板" if x=="30"
                                            else "深市ETF基金" if x=="15"
                                          else "沪市主板" if x=="60"
                                            else "沪市可转债" if x=="12"
                                          else "沪市ETF基金" if x=="51" else "沪市ETF基金" if x=="56"  else "沪市ETF基金" if x=="58"
                                            else "沪市科创板" if x=="68"
                                            else "北交所股票" if x=="43"
                                            else "北交所股票" if x=="83"
                                            else "北交所股票" if x=="87"
                                            else "北交所股票" if x=="92"
                                           else '--')
    log.info("已经预处理持仓数据，增加证券分类")
    saveCsvByTime("交易可用数清单",执行清单,False,"","outPut")
    log.info(f"已经保存交易可用数清单")
    return 执行清单


交易可用清单=预处理原始数据()
# 交易可用清单=pd.read_csv(os.path.join(r"D:\Users\AXZQ\PycharmProjects\pythonProject\outPut","交易可用数清单.csv"))       #【测试数据来源】

#追加没有可用的码表
全量码表=pd.read_excel(os.path.join(os.path.join(pyPath,"dataEx"),"代码表.xls"))
T0全量码表=pd.read_excel(os.path.join(os.path.join(pyPath,"dataEx"),"T0价差标的代码表.xls"))



# 计算每个资金账号品种的可用数
资金账号品种可用汇总=pd.DataFrame(columns=["账号","账号类型","证券分类","普通卖出","卖券还款","买券还券","融券卖出"])
交易可用清单资金账号列表=list(set(交易可用清单["账号"].tolist()))  #进行账号去重
for 资金账号 in 交易可用清单资金账号列表:
    if 资金账号 in 任务配置列表[任务配置列表["账号"]==资金账号]["账号"].tolist():
        账户类型=任务配置列表[任务配置列表["账号"]==资金账号]["账号类型"].iloc[0]
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:
            普通卖出汇总=((交易可用清单["普通卖出可用数"]>0) & (交易可用清单["证券分类"]==证券分类)).sum()
            卖券还款汇总=((交易可用清单["卖券还款可用数"]>0 )& (交易可用清单["证券分类"]==证券分类)).sum()
            买券还券汇总=((交易可用清单["未还融券数量"]>0) & (交易可用清单["证券分类"]==证券分类)).sum()
            融券卖出汇总=((交易可用清单["融券可用头寸"]>0 )& (交易可用清单["证券分类"]==证券分类)).sum()
            汇总信息=[资金账号,账户类型,证券分类,普通卖出汇总,卖券还款汇总,买券还券汇总,融券卖出汇总]
            汇总可用信息=pd.DataFrame([汇总信息])
            汇总可用信息.columns=["账号","账号类型","证券分类","普通卖出","卖券还款","买券还券","融券卖出"]
            资金账号品种可用汇总=pd.concat([资金账号品种可用汇总,汇总可用信息])
    else:
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:
            普通卖出汇总=0
            卖券还款汇总=0
            买券还券汇总=0
            融券卖出汇总=0
            汇总信息=[资金账号,"",证券分类,普通卖出汇总,卖券还款汇总,买券还券汇总,融券卖出汇总]
            汇总可用信息=pd.DataFrame([汇总信息])
            汇总可用信息.columns=["账号","账号类型","证券分类","普通卖出","卖券还款","买券还券","融券卖出"]
            资金账号品种可用汇总=pd.concat([资金账号品种可用汇总,汇总可用信息])
    #获取融资标的清单
    融资标的=pd.read_excel(os.path.join(os.path.join(pyPath,"dataEx"),"融资标的信息.xls"))
    融资标的["证券分类"]=融资标的["strSecurityID"].str[:2].apply(lambda x:"深市主板" if x=="00"
                                            else "深市可转债" if x=="11"
                                          else "深市创业板" if x=="30"
                                            else "深市ETF基金" if x=="15"
                                          else "沪市主板" if x=="60"
                                            else "沪市可转债" if x=="12"
                                          else "沪市ETF基金" if x=="51" else "沪市ETF基金" if x=="56"  else "沪市ETF基金" if x=="58"
                                            else "沪市科创板" if x=="68"
                                                else "北交所股票" if x=="43"
                                            else "北交所股票" if x=="83"
                                            else "北交所股票" if x=="87"
                                           else '--')


# 初始化导入模板数据
算法交易导入模板=pd.DataFrame(columns=["账户类型","账户","代码","交易方向","目标量","目标金额","算法类型","算法参数"])
网格交易导入模板=pd.DataFrame(columns=["账号类型","账号","代码","买入方向（1：普通买入；A：融资买入）","卖出方向（2：普通卖出；D：卖券还款）","买入价位","买入价位偏移-跳","买入价位偏移-比例"
                               ,"卖出价位","卖出价位偏移-跳","卖出价位偏移-比例","初始基准价格","价差类型（1:绝对价差，2：百分比价差）","买入价差","卖出价差","基准价更新方式（1.成交价;2.按价差）","价格上限","价格下限","单次委托数量",
                               "最大买入数量","最大卖出数量","最大买卖轧差","提前挂买单（0否，1是）","提前挂卖单（0否，1是）","策略名称备注","结束日期","次日自动启动（0否，1是）"])
算法单导入T0模板=pd.DataFrame(columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"])

组合交易导入模板=pd.DataFrame(columns=["账户类型","账户","代码","数量","买卖方向","委托价"])
价差策略导入模板=pd.DataFrame(columns=["账号类型","账号","代码","开始时间","结束时间","今敞口阈值-数量","今敞口阈值-金额","单次委托-数量","单次委托-金额","佣金率","价差乘数","结束日期","次日自动启动（0否，1是）","备注","策略停止强制平敞口（0否，1是）"])
导出算法交易标识=False
导出网格交易标识=False
导出组合交易标识=False
导出价差策略标识=False
导出算法单导入T0标识=False
是否生成DMA扫单=False
是否生成算法单扫单=False



#自动生成导入模板
for index,row in 任务配置列表.iterrows():
    if row["菜单"]=="算法交易":
        导出算法交易标识=True
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成算法交易模板：{资金账号}】")
        账号类型=row["账号类型"]
        算法类型=row["子策略"]
        交易标的总数=int(row["深市主板"])+int(row["深市可转债"])+int(row["深市创业板"])+int(row["深市ETF基金"])+int(row["沪市主板"])+int(row["沪市可转债"])+int(row["沪市ETF基金"])+int(row["沪市科创板"]+int(row["北交所股票"]))

        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:

            # 处理普通卖出算法模板
            交易可用普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(交易可用普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                普通卖出执行数=0
            else:
                if 账号类型  not in["UFC","UMC","ATC"]:
                    普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                else:
                    普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                普通卖出样本=交易可用普通卖出底仓.sample(min(普通卖出执行数,len(交易可用普通卖出底仓)))
            log.info(f"普通卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{普通卖出执行数}")
            if len(交易可用普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=len(普通卖出样本)
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                for index1,row1 in 普通卖出样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法交易普通卖出指令记录=[账号类型,资金账号,row1["证券代码"],"2",str(每手取整(row1["证券代码"],row1["普通卖出可用数"],maxEable)),"",算法类型,算法参数]

                    算法交易普通卖出指令=pd.DataFrame([算法交易普通卖出指令记录])
                    算法交易普通卖出指令.columns=["账户类型","账户","代码","交易方向","目标量","目标金额","算法类型","算法参数"]
                    算法交易导入模板=pd.concat([算法交易导入模板,算法交易普通卖出指令])

            # 处理普通买入算法模板
            if 账号类型  not in["UFC","UMC","ATC"]:
                普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-普通卖出执行数,miniNum))
            else:
                普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*buyRate,miniNum))
            log.info(f"普通买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                母单序号=普通买入执行数
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                for i in range(普通买入执行数):
                    # 生成买入算法交易指令
                    普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())
                    # 根据不同算法，生成算法参数
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法交易普通买入指令记录=[账号类型,资金账号,普通买入证券代码,"1",str(random.randint(1,100)*200),"",算法类型,算法参数]
                    算法交易普通买入指令=pd.DataFrame([算法交易普通买入指令记录])
                    算法交易普通买入指令.columns=["账户类型","账户","代码","交易方向","目标量","目标金额","算法类型","算法参数"]
                    算法交易导入模板=pd.concat([算法交易导入模板,算法交易普通买入指令])

            # 处理融资买入算法模板
            if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"] and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                融资买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*finBuyRate,miniNum))
                log.info(f"融资买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{融资买入执行数}")
                # 从全码表随机抽取代码
                母单序号=融资买入执行数
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                for i in range(融资买入执行数):
                    # 生成融资买入算法交易指令
                    融资买入证券代码=random.choice(融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist())
                    # 根据不同算法，生成算法参数
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法交易融资买入指令记录=[账号类型,资金账号,融资买入证券代码,"A",str(random.randint(1,100)*200),"",算法类型,算法参数]
                    算法交易融资买入指令=pd.DataFrame([算法交易融资买入指令记录])
                    算法交易融资买入指令.columns=["账户类型","账户","代码","交易方向","目标量","目标金额","算法类型","算法参数"]
                    算法交易导入模板=pd.concat([算法交易导入模板,算法交易融资买入指令])
            else:
                # 信用户特殊处理可转债
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融资买入，不生成对应模板")
                continue



            # 处理卖券还款算法模板
            交易可用卖券还款底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["卖券还款可用数"]>0)]
            if len(交易可用卖券还款底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，卖券还款没有底仓，不生成对应模板")
                卖券还款执行数=0
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    卖券还款执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*(1-finBuyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["卖券还款"].iloc[0])
                    log.info(f"卖券还款算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{卖券还款执行数}")
                else:
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持卖券还款，不生成对应模板")
                    continue
                卖券还款样本=交易可用卖券还款底仓.sample(min(卖券还款执行数,len(交易可用卖券还款底仓)))
            if len(交易可用卖券还款底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=min(卖券还款执行数,len(交易可用卖券还款底仓))
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                for index2,row2 in 卖券还款样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法交易卖券还款指令记录=[账号类型,资金账号,row2["证券代码"],"D",str(每手取整(row2["证券代码"],row2["卖券还款可用数"],maxEable)),"",算法类型,算法参数]
                    算法交易卖券还款指令=pd.DataFrame([算法交易卖券还款指令记录])
                    算法交易卖券还款指令.columns=["账户类型","账户","代码","交易方向","目标量","目标金额","算法类型","算法参数"]
                    算法交易导入模板=pd.concat([算法交易导入模板,算法交易卖券还款指令])





            # 处理融券卖出算法模板


            交易可用融券卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["融券可用头寸"]>0)]
            if len(交易可用融券卖出底仓)==0 and 账号类型  in ["UFC","UMC","ATC"] :
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，融券卖出没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    融券卖出执行数=int(交易标的总数/sloBase+1)*sloSellBase
                    log.info(f"融券卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{融券卖出执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融券卖出，不生成对应模板")
                    continue
                融券卖出样本=交易可用融券卖出底仓.sample(min(融券卖出执行数,len(交易可用融券卖出底仓)))
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=min(融券卖出执行数,len(交易可用融券卖出底仓))
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                for index3,row3 in 融券卖出样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法交易融券卖出指令记录=[账号类型,资金账号,row3["证券代码"],"B",str(min(每手取整(row3["证券代码"],row3["融券可用头寸"],maxEable),2000)),"",算法类型,算法参数]
                    算法交易融券卖出指令=pd.DataFrame([算法交易融券卖出指令记录])
                    算法交易融券卖出指令.columns=["账户类型","账户","代码","交易方向","目标量","目标金额","算法类型","算法参数"]
                    算法交易导入模板=pd.concat([算法交易导入模板,算法交易融券卖出指令])


            # 处理买券还券算法模板

            交易可用买券还券底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["未还融券数量"]>0)]
            if len(交易可用买券还券底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，买券还券没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    买券还券执行数=int(交易标的总数/sloBase+1)*sloBuyBase
                    log.info(f"买券还券算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{买券还券执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持买券还券，不生成对应模板")
                    continue
                买券还券样本=交易可用买券还券底仓.sample(min(买券还券执行数,len(交易可用买券还券底仓)))
            if 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=min(买券还券执行数,len(交易可用买券还券底仓))
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                for index4,row4 in 买券还券样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法交易买券还券指令记录=[账号类型,资金账号,row4["证券代码"],"C",每手取整(row4["证券代码"],row4["未还融券数量"],maxEable),"",算法类型,算法参数]
                    算法交易买券还券指令=pd.DataFrame([算法交易买券还券指令记录])
                    算法交易买券还券指令.columns=["账户类型","账户","代码","交易方向","目标量","目标金额","算法类型","算法参数"]
                    算法交易导入模板=pd.concat([算法交易导入模板,算法交易买券还券指令])

    # 处理T0算法模板
    elif row["菜单"]=="T0算法":
        资金账号=row["账号"]
        T0算法导入模板=pd.DataFrame(columns=["代码","授权使用量"])
        for 证券分类 in ["深市主板","深市创业板","沪市主板","沪市科创板","北交所股票"]:

            # 处理T0算法模板
            交易可用普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(交易可用普通卖出底仓)==0:
                log.info(f"{资金账号},{证券分类}，普通卖出没有底仓，不生成对应模板")
                T0底仓执行数=0
            else:

                T0底仓执行数=任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]
                普通卖出样本=交易可用普通卖出底仓.sample(min(T0底仓执行数,len(交易可用普通卖出底仓)))
            log.info(f"T0算法模板开始生成：{资金账号}、证券分类：{证券分类}，执行记录数：{T0底仓执行数}")
            if len(交易可用普通卖出底仓)!=0:
                for index1,row1 in 普通卖出样本.iterrows():
                    T0普通卖出指令记录=[row1["证券代码"],str(每手取整(row1["证券代码"],row1["普通卖出可用数"],maxEable))]
                    T0普通卖出指令=pd.DataFrame([T0普通卖出指令记录])
                    T0普通卖出指令.columns=["代码","授权使用量"]
                    T0算法导入模板=pd.concat([T0算法导入模板,T0普通卖出指令])
        # 每个T0任务导出对应模板
        saveCsvByTime("T0算法模板_"+str(资金账号)+"_"+str(账号类型),T0算法导入模板,True,"ANSI","outPut")
        log.info(f"资金账号：{资金账号}T0算法导入模板已导出")


    elif row["菜单"]=="调仓算法":
        调仓算法导入模板=pd.DataFrame(columns=["代码","目标数量"])
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成调仓算法模板：{资金账号}】")
        账号类型=row["账号类型"]
        交易标的总数=int(row["深市主板"])+int(row["深市可转债"])+int(row["深市创业板"])+int(row["深市ETF基金"])+int(row["沪市主板"])+int(row["沪市可转债"])+int(row["沪市ETF基金"])+int(row["沪市科创板"]+int(row["北交所股票"]))

        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:

            # 处理普通卖出算法模板
            调仓算法普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(调仓算法普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                调仓算法普通卖出执行数=0
            else:
                调仓算法普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                调仓算法普通卖出样本=调仓算法普通卖出底仓.sample(min(调仓算法普通卖出执行数,len(调仓算法普通卖出底仓)))
            log.info(f"卖出方向调仓算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{调仓算法普通卖出执行数}")
            if len(调仓算法普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index1,row1 in 调仓算法普通卖出样本.iterrows():
                    调仓算法普通卖出指令记录=[row1["证券代码"],str(每手取整(row1["证券代码"],row1["普通卖出可用数"],random.uniform(algoMoveDownlimit, 1)))]

                    调仓算法普通卖出指令=pd.DataFrame([调仓算法普通卖出指令记录])
                    调仓算法普通卖出指令.columns=["代码","目标数量"]
                    调仓算法导入模板=pd.concat([调仓算法导入模板,调仓算法普通卖出指令])

            # 处理普通买入算法模板
            调仓算法普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-调仓算法普通卖出执行数,miniNum))
            log.info(f"买入方向调仓算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{调仓算法普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                for i in range(调仓算法普通买入执行数):
                    # 生成买入算法交易指令
                    调仓算法普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())

                    调仓算法普通买入指令记录=[调仓算法普通买入证券代码,str(每手取整(row1["证券代码"],row1["普通卖出可用数"],random.uniform(1, algoMoveUplimit)))]
                    调仓算法普通买入指令=pd.DataFrame([调仓算法普通买入指令记录])
                    调仓算法普通买入指令.columns=["代码","目标数量"]
                    调仓算法导入模板=pd.concat([调仓算法导入模板,调仓算法普通买入指令])
        # 每个调仓算法任务导出对应模板
        saveCsvByTime("调仓算法模板_"+str(资金账号)+"_"+str(账号类型),调仓算法导入模板,True,"ANSI","outPut")
        log.info(f"资金账号：{资金账号}调仓算法导入模板已导出")

    elif row["菜单"]=="网格交易":
        导出网格交易标识=True
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成网格交易模板：{资金账号}】")
        账号类型=row["账号类型"]
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:

            # 处理普通卖出算法模板
            网格交易普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0.0)]

            if len(网格交易普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                网格交易普通卖出执行数=0
            else:
                网格交易普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0],miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                网格交易普通卖出样本=网格交易普通卖出底仓.sample(min(网格交易普通卖出执行数,len(网格交易普通卖出底仓)))
            log.info(f"网格交易模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{网格交易普通卖出执行数}")
            if len(网格交易普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index5,row5 in 网格交易普通卖出样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    if 账号类型 in ["UFC","UMC","ATC"]:


                        if row5["证券代码"] in 融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist():
                            买入方向=random.choice(["1","A"])
                            卖出方向=random.choice(["2","D"])
                        else:
                            买入方向="1"
                            卖出方向="2"
                    else:
                        买入方向="1"
                        卖出方向="2"
                    买入价位=random.choice(["P8","P9","P10","P11","P12","P13"])
                    卖出价位=random.choice(["P8","P19","P20","P21","P22","P23"])
                    # 处理偏离设置
                    偏离设置=random.choice(["跳","比例","","跳","比例"])
                    if 偏离设置=="":
                        买入价位偏移跳=0
                        买入价位偏移比例=0
                        卖出价位偏移跳=0
                        卖出价位偏移比例=0
                    elif 偏离设置=="跳":
                        买入价位偏移跳=random.choice(["1","3","5","7"])
                        买入价位偏移比例=0
                        卖出价位偏移跳=random.choice(["1","3","5","7"])
                        卖出价位偏移比例=0
                    elif 偏离设置=="比例":
                        买入价位偏移跳=0
                        买入价位偏移比例=round(random.uniform(0,0.015),4)
                        卖出价位偏移跳=0
                        卖出价位偏移比例=round(random.uniform(0,0.015),4)
                    # 基准价格取当天或者昨日的均价
                    初始基准价格=tencentQuo(row5["证券代码"],"均价")
                    if tencentQuo(row5["证券代码"],"均价")==0:
                        初始基准价格=tencentQuo(row5["证券代码"],"close")
                    elif tencentQuo(row5["证券代码"],"均价")==None:
                        continue
                    # 处理价差设置
                    价差设置=random.choice(["跳","比例"])

                    if 价差设置=="跳":
                        价差类型=1

                        涨跌停偏离=min(abs(初始基准价格-tencentQuo(row5["证券代码"],"涨停价")),abs(初始基准价格-tencentQuo(row5["证券代码"],"跌停价")))
                        买入价差=max(min(round(random.uniform(gridRateDownLimit,gridRateUpLimit)*tencentQuo(row5["证券代码"],"now"),2),round(涨跌停偏离*0.5,2)),0.05) #最低0.05
                        卖出价差=买入价差
                    elif 价差设置=="比例":
                        价差类型=2

                        涨跌停偏离=min(
                            abs((初始基准价格-tencentQuo(row5["证券代码"],"涨停价"))/初始基准价格)
                            ,abs((初始基准价格-tencentQuo(row5["证券代码"],"跌停价"))/初始基准价格))
                        买入价差=max(min(round(random.uniform(gridRateDownLimit,gridRateUpLimit),4),round(涨跌停偏离*0.5,4)),0.005)   #最低0.5%
                        卖出价差=买入价差
                    基准价更新方式=random.choice([1,1,1,1,1,1,1,2,2,2])
                    价格下限=tencentQuo(row5["证券代码"],"跌停价")
                    价格上限=tencentQuo(row5["证券代码"],"涨停价")
                    单次委托数量=str(每手取整(row5["证券代码"],row5["普通卖出可用数"],gridOrderNum))
                    最大卖出数量=99000000
                    最大买入数量=最大卖出数量
                    #根据不同品种处理买卖轧差：
                    if 证券分类 in ["深市可转债","沪市可转债"]:
                        最大买卖轧差=random.choice([200,300,500,1000,2000,5000,9900000,str(每手取整(row5["证券代码"],row5["普通卖出可用数"],0.5))])  #半成底仓作为敞口上限
                        单次委托数量=max(int(str(每手取整(row5["证券代码"],row5["普通卖出可用数"],gridOrderNum))),10)
                    elif 证券分类 in ["深市主板","深市创业板","深市ETF基金","沪市主板","沪市ETF基金","沪市科创板","北交所股票"]:
                        最大买卖轧差=random.choice([2000,3000,5000,10000,20000,50000,9900000,str(每手取整(row5["证券代码"],row5["普通卖出可用数"],0.5))])
                        单次委托数量=max(int(str(每手取整(row5["证券代码"],row5["普通卖出可用数"],gridOrderNum))),100)
                        if 证券分类 =="沪市科创板":
                            单次委托数量=max(int(str(每手取整(row5["证券代码"],row5["普通卖出可用数"],gridOrderNum))),200)
                        elif 证券分类=="北交所股票":
                            单次委托数量=max(int(str(每手取整(row5["证券代码"],row5["普通卖出可用数"],gridOrderNum))),100)
                    if int(单次委托数量)>=int(最大买卖轧差):
                        最大买卖轧差=5*int(单次委托数量)
                    提前挂单=[1,1,1,1,1,1,1,1,1,0]
                    提前挂买单=random.choice(提前挂单)
                    提前挂卖单=提前挂买单
                    策略名称备注=""
                    结束日期=datetime.datetime.now().strftime("%Y%m%d")
                    自动启动=0
                    网格交易指令记录=[账号类型,资金账号,row5["证券代码"],买入方向,卖出方向,买入价位,买入价位偏移跳,买入价位偏移比例,卖出价位,卖出价位偏移跳,卖出价位偏移比例,初始基准价格,价差类型,买入价差,卖出价差,基准价更新方式,价格上限,价格下限,单次委托数量,最大买入数量,最大卖出数量,最大买卖轧差,提前挂买单,提前挂卖单,策略名称备注,结束日期,自动启动]

                    网格交易指令=pd.DataFrame([网格交易指令记录])
                    网格交易指令.columns=["账号类型","账号","代码","买入方向（1：普通买入；A：融资买入）","卖出方向（2：普通卖出；D：卖券还款）","买入价位","买入价位偏移-跳","买入价位偏移-比例"
                               ,"卖出价位","卖出价位偏移-跳","卖出价位偏移-比例","初始基准价格","价差类型（1:绝对价差，2：百分比价差）","买入价差","卖出价差","基准价更新方式（1.成交价;2.按价差）","价格上限","价格下限","单次委托数量",
                               "最大买入数量","最大卖出数量","最大买卖轧差","提前挂买单（0否，1是）","提前挂卖单（0否，1是）","策略名称备注","结束日期","次日自动启动（0否，1是）"]
                    网格交易导入模板=pd.concat([网格交易导入模板,网格交易指令])

    elif row["菜单"]=="组合交易":
        导出组合交易标识=True
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成组合交易模板：{资金账号}】")
        账号类型=row["账号类型"]
        交易标的总数=int(row["深市主板"])+int(row["深市可转债"])+int(row["深市创业板"])+int(row["深市ETF基金"])+int(row["沪市主板"])+int(row["沪市可转债"])+int(row["沪市ETF基金"])+int(row["沪市科创板"]+int(row["北交所股票"]))
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:

            # 处理普通卖出算法模板
            组合交易普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(组合交易普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                组合交易普通卖出执行数=0
            else:
                if 账号类型  not in["UFC","UMC","ATC"]:
                    组合交易普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                else:
                    组合交易普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                组合交易普通卖出样本=组合交易普通卖出底仓.sample(min(组合交易普通卖出执行数,len(组合交易普通卖出底仓)))
            log.info(f"组合交易普通卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{组合交易普通卖出执行数}")
            if len(组合交易普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index6,row6 in 组合交易普通卖出样本.iterrows():
                    组合交易普通卖出指令记录=[账号类型,资金账号,row6["证券代码"],str(每手取整(row6["证券代码"],row6["普通卖出可用数"],maxEable)),"2",tencentQuo(row6["证券代码"],"now")]
                    组合交易普通卖出指令=pd.DataFrame([组合交易普通卖出指令记录])
                    组合交易普通卖出指令.columns=["账户类型","账户","代码","数量","买卖方向","委托价"]
                    组合交易导入模板=pd.concat([组合交易导入模板,组合交易普通卖出指令])

            # 处理普通买入算法模板
            if 账号类型  not in["UFC","UMC","ATC"]:
                组合交易普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-组合交易普通卖出执行数,miniNum))
            else:
                组合交易普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*buyRate,miniNum))
            log.info(f"组合交易普通买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{组合交易普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                for i in range(组合交易普通买入执行数):
                    # 生成买入算法交易指令
                    组合交易普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())
                    组合交易普通买入指令记录=[账号类型,资金账号,组合交易普通买入证券代码,str(random.randint(1,100)*200),"1",tencentQuo(组合交易普通买入证券代码,"now")]
                    组合交易普通买入指令=pd.DataFrame([组合交易普通买入指令记录])

                    组合交易普通买入指令.columns=["账户类型","账户","代码","数量","买卖方向","委托价"]
                    组合交易导入模板=pd.concat([组合交易导入模板,组合交易普通买入指令])


            # 处理融资买入算法模板
            if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"] and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                组合交易融资买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*finBuyRate,miniNum))
                log.info(f"组合交易融资买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{组合交易融资买入执行数}")
                # 从全码表随机抽取代码
                for i in range(组合交易融资买入执行数):
                    # 生成融资买入算法交易指令
                    组合交易融资买入证券代码=random.choice(融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist())
                    # 根据不同算法，生成算法参数
                    组合交易融资买入指令记录=[账号类型,资金账号,组合交易融资买入证券代码,str(random.randint(1,100)*200),"A",tencentQuo(组合交易融资买入证券代码,"now")]
                    组合交易融资买入指令=pd.DataFrame([组合交易融资买入指令记录])
                    组合交易融资买入指令.columns=["账户类型","账户","代码","数量","买卖方向","委托价"]
                    组合交易导入模板=pd.concat([组合交易导入模板,组合交易融资买入指令])

            else:
                # 信用户特殊处理可转债
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融资买入，不生成对应模板")
                continue

            # 处理卖券还款算法模板
            组合交易卖券还款底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["卖券还款可用数"]>0)]
            if len(组合交易卖券还款底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，卖券还款没有底仓，不生成对应模板")
                组合交易卖券还款执行数=0
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    组合交易卖券还款执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*(1-finBuyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["卖券还款"].iloc[0])
                    log.info(f"组合交易卖券还款算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{组合交易卖券还款执行数}")
                else:
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持卖券还款，不生成对应模板")
                    continue
                组合交易卖券还款样本=组合交易卖券还款底仓.sample(min(组合交易卖券还款执行数,len(组合交易卖券还款底仓)))
            if len(组合交易卖券还款底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index7,row7 in 组合交易卖券还款样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    组合交易卖券还款指令记录=[账号类型,资金账号,row7["证券代码"],str(random.randint(1,100)*200),"A",tencentQuo(row7["证券代码"],"now")]
                    组合交易卖券还款指令=pd.DataFrame([组合交易卖券还款指令记录])
                    组合交易卖券还款指令.columns=["账户类型","账户","代码","数量","买卖方向","委托价"]
                    组合交易导入模板=pd.concat([组合交易导入模板,组合交易卖券还款指令])


            # 处理融券卖出算法模板
            组合交易融券卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["融券可用头寸"]>0)]
            if len(组合交易融券卖出底仓)==0 and 账号类型  in ["UFC","UMC","ATC"] :
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，融券卖出没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    组合交易融券卖出执行数=int(交易标的总数/sloBase+1)*sloSellBase
                    log.info(f"组合交易融券卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{组合交易融券卖出执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融券卖出，不生成对应模板")
                    continue
                组合交易融券卖出样本=组合交易融券卖出底仓.sample(min(组合交易融券卖出执行数,len(组合交易融券卖出底仓)))
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index8,row8 in 组合交易融券卖出样本.iterrows():
                    组合交易融券卖出指令记录=[账号类型,资金账号,row8["证券代码"],str(min(每手取整(row8["证券代码"],row8["融券可用头寸"],maxEable),2000)),"B",tencentQuo(row8["证券代码"],"now")]
                    组合交易融券卖出指令=pd.DataFrame([组合交易融券卖出指令记录])
                    组合交易融券卖出指令.columns=["账户类型","账户","代码","数量","买卖方向","委托价"]
                    组合交易导入模板=pd.concat([组合交易导入模板,组合交易融券卖出指令])

            # 处理买券还券算法模板
            组合交易买券还券底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["未还融券数量"]>0)]
            if len(组合交易买券还券底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，买券还券没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    组合交易买券还券执行数=int(交易标的总数/sloBase+1)*sloBuyBase
                    log.info(f"组合交易买券还券算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{组合交易买券还券执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持买券还券，不生成对应模板")
                    continue
                组合交易买券还券样本=组合交易买券还券底仓.sample(min(组合交易买券还券执行数,len(组合交易买券还券底仓)))
            if 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index9,row9 in 组合交易买券还券样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    组合交易买券还券指令记录=[账号类型,资金账号,row9["证券代码"],每手取整(row9["证券代码"],row9["未还融券数量"],maxEable),"C",tencentQuo(row9["证券代码"],"now")]
                    组合交易买券还券指令=pd.DataFrame([组合交易买券还券指令记录])
                    组合交易买券还券指令.columns=["账户类型","账户","代码","数量","买卖方向","委托价"]
                    组合交易导入模板=pd.concat([组合交易导入模板,组合交易买券还券指令])

    elif row["菜单"]=="调仓算法-权重":
        调仓算法导入模板=pd.DataFrame(columns=["代码","目标权重(%)"])
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成调仓算法-权重模板：{资金账号}】")
        账号类型=row["账号类型"]
        持仓列表=pd.read_csv(os.path.join(os.path.join(pyPath,"OQData"),"positioninfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
        总市值=持仓列表[持仓列表["账号"]==资金账号]["当前市值"].sum()
        资产列表=pd.read_csv(os.path.join(os.path.join(pyPath,"OQData"),"assetInfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))

        if 账号类型 not in ["AT0","UM0","UF0"]:
            continue
        else:
            总资产=资产列表[资产列表["账号"]==资金账号]["总资产"].iloc[0]
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板""北交所股票"]:
            # 处理普通卖出算法模板
            调仓算法普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(调仓算法普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                调仓算法普通卖出执行数=0
            else:
                调仓算法普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                调仓算法普通卖出样本=调仓算法普通卖出底仓.sample(min(调仓算法普通卖出执行数,len(调仓算法普通卖出底仓)))
            log.info(f"卖出方向调仓算法权重模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{调仓算法普通卖出执行数}")
            if len(调仓算法普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index1,row1 in 调仓算法普通卖出样本.iterrows():
                    减仓权重=round(每手取整(row1["证券代码"],row1["普通卖出可用数"],random.uniform(algoMoveDownlimit, 1))*tencentQuo(row1["证券代码"],"now")/总资产,4)
                    调仓算法普通卖出指令记录=[row1["证券代码"],减仓权重]

                    调仓算法普通卖出指令=pd.DataFrame([调仓算法普通卖出指令记录])
                    调仓算法普通卖出指令.columns=["代码","目标权重(%)"]
                    调仓算法导入模板=pd.concat([调仓算法导入模板,调仓算法普通卖出指令])

            # 处理普通买入算法模板
            调仓算法普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-调仓算法普通卖出执行数,miniNum))
            log.info(f"买入方向调仓算法权重模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{调仓算法普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                for i in range(调仓算法普通买入执行数):
                    # 生成买入算法交易指令
                    调仓算法普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())
                    增仓权重=max(round(每手取整(row1["证券代码"],row1["普通卖出可用数"],random.uniform(1, algoMoveUplimit))*tencentQuo(调仓算法普通买入证券代码,"now")/总资产,4),random.choice([0.01,0.02,0.03,0.04,0.05,0.06,0.07]))
                    调仓算法普通买入指令记录=[调仓算法普通买入证券代码,增仓权重]
                    调仓算法普通买入指令=pd.DataFrame([调仓算法普通买入指令记录])
                    调仓算法普通买入指令.columns=["代码","目标权重(%)"]
                    调仓算法导入模板=pd.concat([调仓算法导入模板,调仓算法普通买入指令])
        # 每个调仓算法任务导出对应模板
        saveCsvByTime("调仓算法权重模板_"+str(资金账号)+"_"+str(账号类型),调仓算法导入模板,True,"ANSI","outPut")
        log.info(f"资金账号：{资金账号}调仓算法权重导入模板已导出")


    elif row["菜单"]=="锁仓算法":

        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成锁仓算法模板：{资金账号}】")
        账号类型=row["账号类型"]
        # 处理普通买入-融券卖出算法模板
        锁仓算法导入模板=pd.DataFrame(columns=["代码","买入方向（1:普通买入;A:融资买入）","委托数量"])
        for 证券分类 in ["深市主板","深市创业板","深市ETF基金","沪市主板","沪市ETF基金","沪市科创板","北交所股票"]:
            锁仓算法融券卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["融券可用头寸"]>0)]
            if len(锁仓算法融券卖出底仓)==0 and 账号类型  in ["UFC","UMC","ATC"] :
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，融券卖出没有底仓，不生成对应模板")
                continue
            else:
                锁仓算法融券卖出样本=锁仓算法融券卖出底仓.sample(min(row[证券分类],len(锁仓算法融券卖出底仓)))
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index8,row8 in 锁仓算法融券卖出样本.iterrows():
                    锁仓算法融券卖出指令记录=[row8["证券代码"],"1",str(min(每手取整(row8["证券代码"],row8["融券可用头寸"],maxEable),2000))]
                    锁仓算法融券卖出指令=pd.DataFrame([锁仓算法融券卖出指令记录])
                    锁仓算法融券卖出指令.columns=["代码","买入方向（1:普通买入;A:融资买入）","委托数量"]
                    锁仓算法导入模板=pd.concat([锁仓算法导入模板,锁仓算法融券卖出指令])
        # 每个调仓算法任务导出对应模板
        saveCsvByTime("锁仓算法普通买入模板_"+str(资金账号)+"_"+str(账号类型),锁仓算法导入模板,True,"ANSI","outPut")
        log.info(f"资金账号：{资金账号}锁仓算法普通买入导入模板已导出")

        # 处理融资买入-融券卖出算法模板
        锁仓算法导入模板=pd.DataFrame(columns=["代码","买入方向（1:普通买入;A:融资买入）","委托数量"])
        for 证券分类 in ["深市主板","深市创业板","深市ETF基金","沪市主板","沪市ETF基金","沪市科创板","北交所股票"]:
            锁仓算法融券卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["融券可用头寸"]>0)]
            if len(锁仓算法融券卖出底仓)==0 and 账号类型  in ["UFC","UMC","ATC"] :
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，融券卖出没有底仓，不生成对应模板")
                continue
            else:
                锁仓算法融券卖出样本=锁仓算法融券卖出底仓.sample(min(row[证券分类],len(锁仓算法融券卖出底仓)))
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index8,row8 in 锁仓算法融券卖出样本.iterrows():
                    if row8["证券代码"] in 融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist():
                        锁仓算法融券卖出指令记录=[row8["证券代码"],"A",str(min(每手取整(row8["证券代码"],row8["融券可用头寸"],maxEable),2000))]
                        锁仓算法融券卖出指令=pd.DataFrame([锁仓算法融券卖出指令记录])
                        锁仓算法融券卖出指令.columns=["代码","买入方向（1:普通买入;A:融资买入）","委托数量"]
                        锁仓算法导入模板=pd.concat([锁仓算法导入模板,锁仓算法融券卖出指令])
        # 每个锁仓算法任务导出对应模板
        saveCsvByTime("锁仓算法融资买入模板_"+str(资金账号)+"_"+str(账号类型),锁仓算法导入模板,True,"ANSI","outPut")
        log.info(f"资金账号：{资金账号}锁仓算法融资买入导入模板已导出")

    elif row["菜单"]=="篮子交易":
        篮子交易导入模板=pd.DataFrame(columns=["代码","单篮数量/相对权重","方向"])
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成篮子交易模板：{资金账号}】")
        账号类型=row["账号类型"]
        交易标的总数=int(row["深市主板"])+int(row["深市可转债"])+int(row["深市创业板"])+int(row["深市ETF基金"])+int(row["沪市主板"])+int(row["沪市可转债"])+int(row["沪市ETF基金"])+int(row["沪市科创板"]+int(row["北交所股票"]))
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:

            # 处理普通卖出算法模板
            篮子交易普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(篮子交易普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                篮子交易普通卖出执行数=0
            else:
                if 账号类型  not in["UFC","UMC","ATC"]:
                    篮子交易普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                else:
                    篮子交易普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                篮子交易普通卖出样本=篮子交易普通卖出底仓.sample(min(篮子交易普通卖出执行数,len(篮子交易普通卖出底仓)))
            log.info(f"篮子交易普通卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{篮子交易普通卖出执行数}")
            if len(篮子交易普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index6,row6 in 篮子交易普通卖出样本.iterrows():
                    篮子交易普通卖出指令记录=[row6["证券代码"],str(每手取整(row6["证券代码"],row6["普通卖出可用数"],maxEable)),"2"]
                    篮子交易普通卖出指令=pd.DataFrame([篮子交易普通卖出指令记录])
                    篮子交易普通卖出指令.columns=["代码","单篮数量/相对权重","方向"]
                    篮子交易导入模板=pd.concat([篮子交易导入模板,篮子交易普通卖出指令])

            # 处理普通买入算法模板
            if 账号类型  not in["UFC","UMC","ATC"]:
                篮子交易普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-篮子交易普通卖出执行数,miniNum))
            else:
                篮子交易普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*buyRate,miniNum))
            log.info(f"篮子交易普通买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{篮子交易普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                for i in range(篮子交易普通买入执行数):
                    # 生成买入锁仓指令
                    篮子交易普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())
                    篮子交易普通买入指令记录=[篮子交易普通买入证券代码,str(random.randint(1,100)*200),"1"]
                    篮子交易普通买入指令=pd.DataFrame([篮子交易普通买入指令记录])

                    篮子交易普通买入指令.columns=["代码","单篮数量/相对权重","方向"]
                    篮子交易导入模板=pd.concat([篮子交易导入模板,篮子交易普通买入指令])


            # 处理融资买入算法模板
            if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"] and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                篮子交易融资买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*finBuyRate,miniNum))
                log.info(f"篮子交易融资买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{篮子交易融资买入执行数}")
                # 从全码表随机抽取代码
                for i in range(篮子交易融资买入执行数):
                    # 生成融资买入锁仓指令
                    篮子交易融资买入证券代码=random.choice(融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist())
                    # 根据不同算法，生成算法参数
                    篮子交易融资买入指令记录=[篮子交易融资买入证券代码,str(random.randint(1,100)*200),"A"]
                    篮子交易融资买入指令=pd.DataFrame([篮子交易融资买入指令记录])
                    篮子交易融资买入指令.columns=["代码","单篮数量/相对权重","方向"]
                    篮子交易导入模板=pd.concat([篮子交易导入模板,篮子交易融资买入指令])

            else:
                # 信用户特殊处理可转债
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融资买入，不生成对应模板")
                continue

            # 处理卖券还款算法模板
            篮子交易卖券还款底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["卖券还款可用数"]>0)]
            if len(篮子交易卖券还款底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，卖券还款没有底仓，不生成对应模板")
                篮子交易卖券还款执行数=0
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    篮子交易卖券还款执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*(1-finBuyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["卖券还款"].iloc[0])
                    log.info(f"篮子交易卖券还款算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{篮子交易卖券还款执行数}")
                else:
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持卖券还款，不生成对应模板")
                    continue
                篮子交易卖券还款样本=篮子交易卖券还款底仓.sample(min(篮子交易卖券还款执行数,len(篮子交易卖券还款底仓)))
            if len(篮子交易卖券还款底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index7,row7 in 组合交易卖券还款样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    篮子交易卖券还款指令记录=[row7["证券代码"],str(random.randint(1,100)*200),"A"]
                    篮子交易卖券还款指令=pd.DataFrame([篮子交易卖券还款指令记录])
                    篮子交易卖券还款指令.columns=["代码","单篮数量/相对权重","方向"]
                    篮子交易导入模板=pd.concat([篮子交易导入模板,篮子交易卖券还款指令])
       #按交易方向导出篮子交易明细
        if 账号类型   in ["UFC","UMC","ATC"]:
            for 交易方向 in ["1","2","A","D"]:
                # 每个篮子交易任务导出对应模板
                if 交易方向=="1":
                    对应方向导入模板=篮子交易导入模板[篮子交易导入模板["方向"]=="1"]
                    对应方向导入模板.drop("方向", axis=1, inplace=True)
                    saveCsvByTime("篮子交易数量模板_普通买入_"+str(资金账号)+"_"+str(账号类型),对应方向导入模板,True,"ANSI","outPut")
                    log.info(f"资金账号：{资金账号}篮子交易普通买入导入模板已导出")
                elif 交易方向=="2":
                    对应方向导入模板=篮子交易导入模板[篮子交易导入模板["方向"]=="2"]
                    对应方向导入模板.drop("方向", axis=1, inplace=True)
                    saveCsvByTime("篮子交易数量模板_普通卖出_"+str(资金账号)+"_"+str(账号类型),对应方向导入模板,True,"ANSI","outPut")
                    log.info(f"资金账号：{资金账号}篮子交易普通卖出导入模板已导出")
                elif 交易方向=="A":
                    对应方向导入模板=篮子交易导入模板[篮子交易导入模板["方向"]=="A"]
                    对应方向导入模板.drop("方向", axis=1, inplace=True)
                    saveCsvByTime("篮子交易数量模板_融资买入_"+str(资金账号)+"_"+str(账号类型),对应方向导入模板,True,"ANSI","outPut")
                    log.info(f"资金账号：{资金账号}篮子交易融资买入导入模板已导出")
                elif 交易方向=="D":
                    对应方向导入模板=篮子交易导入模板[篮子交易导入模板["方向"]=="D"]
                    对应方向导入模板.drop("方向", axis=1, inplace=True)
                    saveCsvByTime("篮子交易数量模板_卖券还款_"+str(资金账号)+"_"+str(账号类型),对应方向导入模板,True,"ANSI","outPut")
                    log.info(f"资金账号：{资金账号}篮子交易卖券还款导入模板已导出")
        else:
            for 交易方向 in ["1","2","A","D"]:
                # 每个篮子交易任务导出对应模板
                if 交易方向=="1":
                    对应方向导入模板=篮子交易导入模板[篮子交易导入模板["方向"]=="1"]
                    对应方向导入模板.drop("方向", axis=1, inplace=True)
                    saveCsvByTime("篮子交易数量模板_普通买入_"+str(资金账号)+"_"+str(账号类型),对应方向导入模板,True,"ANSI","outPut")
                    log.info(f"资金账号：{资金账号}篮子交易买入导入模板已导出")
                elif 交易方向=="2":
                    对应方向导入模板=篮子交易导入模板[篮子交易导入模板["方向"]=="2"]
                    对应方向导入模板.drop("方向", axis=1, inplace=True)
                    saveCsvByTime("篮子交易数量模板_普通卖出_"+str(资金账号)+"_"+str(账号类型),对应方向导入模板,True,"ANSI","outPut")
                    log.info(f"资金账号：{资金账号}篮子交易卖出导入模板已导出")


    elif row["菜单"]=="价差策略":
        导出价差策略标识=True
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成价差策略模板：{资金账号}】")
        账号类型=row["账号类型"]
        for 证券分类 in ["深市可转债","深市ETF基金","沪市可转债","沪市ETF基金"]:

            价差策略执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0],miniNum))
            log.info(f"价差策略模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{价差策略执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                for i in range(价差策略执行数):
                    价差策略证券代码=random.choice(T0全量码表[T0全量码表["证券分类"]==证券分类]["代码"].tolist())
                    敞口方式=["数量","金额"]
                    if tencentQuo(价差策略证券代码,"now")==None:
                        continue

                    if random.choice(["数量","金额"])=="数量":
                        if 证券分类 in ["深市可转债","沪市可转债"]:
                            单次委托数量=random.choice([20,50,60,80,100,150,200])
                            今敞口阈值数量=单次委托数量*random.choice([1,2,3,4,5])
                            今敞口阈值金额=0
                            单次委托金额=0
                        elif 证券分类 in ["深市ETF基金","沪市ETF基金"]:
                            单次委托数量=random.choice([200,500,600,800,1000,3000,5000,10000])
                            今敞口阈值数量=单次委托数量*random.choice([1,2,3,4,5])
                            今敞口阈值金额=0
                            单次委托金额=0
                    else:
                        if 证券分类 in ["深市可转债","沪市可转债"]:
                            单次委托金额=round(random.choice([20,50,60,80,100,150,200])*tencentQuo(价差策略证券代码,"now"),2)
                            今敞口阈值金额=round(单次委托金额*random.choice([1,2,3,4,5]),2)  #半成底仓作为敞口上限
                            今敞口阈值数量=0
                            单次委托数量=0
                        elif 证券分类 in ["深市ETF基金","沪市ETF基金"]:
                            单次委托金额=round(random.choice([200,500,600,800,1000,3000,5000,10000])*tencentQuo(价差策略证券代码,"now"),2)
                            今敞口阈值金额=round(单次委托金额*random.choice([1,2,3,4,5]),2)  #半成底仓作为敞口上限
                            今敞口阈值数量=0
                            单次委托数量=0
                    价差乘数=random.choice([1,2,2,3,3,3,4,4,4,4])

                    结束日期=datetime.datetime.now().strftime("%Y%m%d")
                    自动启动=0
                    备注=""
                    强制停敞口=random.choice([1,1,1,1,1,1,1,1,1,0])
                    价差策略指令记录=[账号类型,资金账号,价差策略证券代码,"93000",str(random.choice(随机算法结束时间)),今敞口阈值数量,今敞口阈值金额,单次委托数量,单次委托金额,"0.00015",价差乘数,结束日期,自动启动,备注,强制停敞口]

                    价差策略指令=pd.DataFrame([价差策略指令记录])
                    价差策略指令.columns=["账号类型","账号","代码","开始时间","结束时间","今敞口阈值-数量","今敞口阈值-金额","单次委托-数量","单次委托-金额","佣金率",
                                    "价差乘数","结束日期","次日自动启动（0否，1是）","备注","策略停止强制平敞口（0否，1是）"]
                    价差策略导入模板=pd.concat([价差策略导入模板,价差策略指令])
    #按扫单测试工具生成模板
    elif row["菜单"]=="DMA算法" and DMA2==0:
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成dma模板：{资金账号}】")
        账号类型=row["账号类型"]
        DMA导入模板=pd.DataFrame(columns=["symbol","tradeSide","priceType","PrevClose"])
        交易标的总数=int(row["深市主板"])+int(row["深市可转债"])+int(row["深市创业板"])+int(row["深市ETF基金"])+int(row["沪市主板"])+int(row["沪市可转债"])+int(row["沪市ETF基金"])+int(row["沪市科创板"]+int(row["北交所股票"]))
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:
            # 处理普通卖出算法模板
            DMA普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(DMA普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                DMA普通卖出执行数=0
            else:
                if 账号类型  not in["UFC","UMC","ATC"]:
                    DMA普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                else:
                    DMA普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                DMA普通卖出样本=DMA普通卖出底仓.sample(min(DMA普通卖出执行数,len(DMA普通卖出底仓)))
            log.info(f"DMA普通卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA普通卖出执行数}")
            if len(DMA普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index6,row6 in DMA普通卖出样本.iterrows():
                    DMA普通卖出指令记录=[row6["证券代码"],"2","AT",tencentQuo(row6["证券代码"],"close")]
                    DMA普通卖出指令=pd.DataFrame([DMA普通卖出指令记录])
                    DMA普通卖出指令.columns=["symbol","tradeSide","priceType","PrevClose"]
                    DMA导入模板=pd.concat([DMA导入模板,DMA普通卖出指令])

            # 处理普通买入算法模板
            if 账号类型  not in["UFC","UMC","ATC"]:
                DMA普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-DMA普通卖出执行数,miniNum))
            else:
                DMA普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*buyRate,miniNum))
            log.info(f"DMA普通买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                for i in range(DMA普通买入执行数):
                    # 生成买入锁仓指令
                    DMA普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())
                    DMA普通买入指令记录=[DMA普通买入证券代码,"1","AT",tencentQuo(DMA普通买入证券代码,"close")]
                    DMA普通买入指令=pd.DataFrame([DMA普通买入指令记录])

                    DMA普通买入指令.columns=["symbol","tradeSide","priceType","PrevClose"]
                    DMA导入模板=pd.concat([DMA导入模板,DMA普通买入指令])


            # 处理融资买入算法模板
            if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"] and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                DMA融资买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*finBuyRate,miniNum))
                log.info(f"DMA融资买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA融资买入执行数}")
                # 从全码表随机抽取代码
                for i in range(DMA融资买入执行数):
                    # 生成融资买入锁仓指令
                    DMA融资买入证券代码=random.choice(融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist())
                    # 根据不同算法，生成算法参数
                    DMA融资买入指令记录=[DMA融资买入证券代码,"A","AT",tencentQuo(DMA融资买入证券代码,"close")]
                    DMA融资买入指令=pd.DataFrame([DMA融资买入指令记录])
                    DMA融资买入指令.columns=["symbol","tradeSide","priceType","PrevClose"]
                    DMA导入模板=pd.concat([DMA导入模板,DMA融资买入指令])

            else:
                # 信用户特殊处理可转债
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融资买入，不生成对应模板")
                continue

            # 处理卖券还款算法模板
            DMA卖券还款底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["卖券还款可用数"]>0)]
            if len(DMA卖券还款底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，卖券还款没有底仓，不生成对应模板")
                DMA卖券还款执行数=0
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    DMA卖券还款执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*(1-finBuyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["卖券还款"].iloc[0])
                    log.info(f"DMA卖券还款算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA卖券还款执行数}")
                else:
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持卖券还款，不生成对应模板")
                    continue
                DMA卖券还款样本=DMA卖券还款底仓.sample(min(DMA卖券还款执行数,len(DMA卖券还款底仓)))
            if len(DMA卖券还款底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index7,row7 in DMA卖券还款样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    DMA卖券还款指令记录=[row7["证券代码"],"D","AT",tencentQuo(row7["证券代码"],"close")]
                    DMA卖券还款指令=pd.DataFrame([DMA卖券还款指令记录])
                    DMA卖券还款指令.columns=["symbol","tradeSide","priceType","PrevClose"]
                    DMA导入模板=pd.concat([DMA导入模板,DMA卖券还款指令])


            # 处理融券卖出算法模板
            DMA融券卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["融券可用头寸"]>0)]
            if len(DMA融券卖出底仓)==0 and 账号类型  in ["UFC","UMC","ATC"] :
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，融券卖出没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    DMA融券卖出执行数=int(交易标的总数/sloBase+1)*sloSellBase
                    log.info(f"DMA融券卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA融券卖出执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融券卖出，不生成对应模板")
                    continue
                DMA融券卖出样本=DMA融券卖出底仓.sample(min(DMA融券卖出执行数,len(DMA融券卖出底仓)))
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index8,row8 in DMA融券卖出样本.iterrows():
                    DMA融券卖出指令记录=[row8["证券代码"],"B","AT",tencentQuo(row8["证券代码"],"close")]
                    DMA融券卖出指令=pd.DataFrame([DMA融券卖出指令记录])
                    DMA融券卖出指令.columns=["symbol","tradeSide","priceType","PrevClose"]
                    DMA导入模板=pd.concat([DMA导入模板,DMA融券卖出指令])

            # 处理买券还券算法模板
            DMA买券还券底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["未还融券数量"]>0)]
            if len(DMA买券还券底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，买券还券没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    DMA买券还券执行数=int(交易标的总数/sloBase+1)*sloBuyBase
                    log.info(f"DMA买券还券算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA买券还券执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持买券还券，不生成对应模板")
                    continue
                DMA买券还券样本=DMA买券还券底仓.sample(min(DMA买券还券执行数,len(DMA买券还券底仓)))
            if 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index9,row9 in DMA买券还券样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    DMA买券还券指令记录=[row9["证券代码"],"C","AT",tencentQuo(row9["证券代码"],"close")]
                    DMA买券还券指令=pd.DataFrame([DMA买券还券指令记录])
                    DMA买券还券指令.columns=["symbol","tradeSide","priceType","PrevClose"]
                    DMA导入模板=pd.concat([DMA导入模板,DMA买券还券指令])
        saveCsvByTime("Stock_DMA"+str(资金账号)+"_"+str(账号类型),DMA导入模板,True,"ANSI","outPut")
        log.info(f"资金账号：{资金账号}DMA-STOCK导入模板已导出")

    #按原始文件格式生成模板
    elif row["菜单"]=="DMA算法" and DMA2==1:
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成dma模板：{资金账号}】")
        账号类型=row["账号类型"]
        DMA导入模板=pd.DataFrame(columns=["updTime","custBatchNo","acctType","acct","symbol","tradeSide","targetQty","algoId","priceType","ticks","highLimitPrice","lowLimitPrice"])
        交易标的总数=int(row["深市主板"])+int(row["深市可转债"])+int(row["深市创业板"])+int(row["深市ETF基金"])+int(row["沪市主板"])+int(row["沪市可转债"])+int(row["沪市ETF基金"])+int(row["沪市科创板"]+int(row["北交所股票"]))
        custBatchNo=int(datetime.datetime.now().strftime("%H:%M:%S.%f").replace(":","").replace(".","")[0:8])

        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:
            # 处理普通卖出算法模板
            DMA普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(DMA普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                DMA普通卖出执行数=0
            else:
                if 账号类型  not in["UFC","UMC","ATC"]:
                    DMA普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                else:
                    DMA普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                DMA普通卖出样本=DMA普通卖出底仓.sample(min(DMA普通卖出执行数,len(DMA普通卖出底仓)))
            log.info(f"DMA普通卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA普通卖出执行数}")
            if len(DMA普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index6,row6 in DMA普通卖出样本.iterrows():
                    updTime=datetime.datetime.now().strftime("%H:%M:%S.%f")
                    priceType=random.choice(DMAPriceType.split("&"))


                    for i in range(DMASplit):
                        价格指令=生成DMA价格指令(row6["证券代码"],"卖出")
                        custBatchNo=custBatchNo+1
                        DMA普通卖出指令记录=[updTime,custBatchNo,账号类型,资金账号,row6["证券代码"],2,每手取整(row6["证券代码"],row6["普通卖出可用数"],1/DMASplit*DMASellRate),"DMA",priceType,价格指令[0],价格指令[1],价格指令[2]]
                        DMA普通卖出指令=pd.DataFrame([DMA普通卖出指令记录])
                        DMA普通卖出指令.columns=["updTime","custBatchNo","acctType","acct","symbol","tradeSide","targetQty","algoId","priceType","ticks","highLimitPrice","lowLimitPrice"]
                        DMA导入模板=pd.concat([DMA导入模板,DMA普通卖出指令])

            # 处理普通买入算法模板
            if 账号类型  not in["UFC","UMC","ATC"]:
                DMA普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-DMA普通卖出执行数,miniNum))
            else:
                DMA普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*buyRate,miniNum))
            log.info(f"DMA普通买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                for i in range(DMA普通买入执行数):
                    # 生成买入锁仓指令
                    DMA普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())
                    updTime=datetime.datetime.now().strftime("%H:%M:%S.%f")
                    priceType=random.choice(DMAPriceType.split("&"))



                    for i in range(DMASplit):
                        价格指令=生成DMA价格指令(DMA普通买入证券代码,"买入")
                        custBatchNo=custBatchNo+1
                        DMA普通买入指令记录=[updTime,custBatchNo,账号类型,资金账号,DMA普通买入证券代码,1,random.randint(2, 10)*100,"DMA",priceType,价格指令[0],价格指令[1],价格指令[2]]
                        DMA普通买入指令=pd.DataFrame([DMA普通买入指令记录])
                        DMA普通买入指令.columns=["updTime","custBatchNo","acctType","acct","symbol","tradeSide","targetQty","algoId","priceType","ticks","highLimitPrice","lowLimitPrice"]

                        DMA导入模板=pd.concat([DMA导入模板,DMA普通买入指令])

            # 处理融资买入算法模板
            if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"] and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                DMA融资买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*finBuyRate,miniNum))
                log.info(f"DMA融资买入算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA融资买入执行数}")
                # 从全码表随机抽取代码
                for i in range(DMA融资买入执行数):
                    # 生成融资买入锁仓指令
                    DMA融资买入证券代码=random.choice(融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist())
                    updTime=datetime.datetime.now().strftime("%H:%M:%S.%f")
                    custBatchNo=custBatchNo+1
                    priceType=random.choice(DMAPriceType.split("&"))

                    for i in range(DMASplit):
                        价格指令=生成DMA价格指令(DMA融资买入证券代码,"买入")
                        DMA融资买入指令记录=[updTime,custBatchNo,账号类型,资金账号,DMA融资买入证券代码,"A",random.randint(2, 10)*100,"DMA",priceType,价格指令[0],价格指令[1],价格指令[2]]
                        DMA融资买入指令=pd.DataFrame([DMA融资买入指令记录])
                        DMA融资买入指令.columns=["updTime","custBatchNo","acctType","acct","symbol","tradeSide","targetQty","algoId","priceType","ticks","highLimitPrice","lowLimitPrice"]
                        DMA导入模板=pd.concat([DMA导入模板,DMA融资买入指令])
            else:
                # 信用户特殊处理可转债
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融资买入，不生成对应模板")
                continue

            # 处理卖券还款算法模板
            DMA卖券还款底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["卖券还款可用数"]>0)]
            if len(DMA卖券还款底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，卖券还款没有底仓，不生成对应模板")
                DMA卖券还款执行数=0
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    DMA卖券还款执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*(1-finBuyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["卖券还款"].iloc[0])
                    log.info(f"DMA卖券还款算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA卖券还款执行数}")
                else:
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持卖券还款，不生成对应模板")
                    continue
                DMA卖券还款样本=DMA卖券还款底仓.sample(min(DMA卖券还款执行数,len(DMA卖券还款底仓)))
            if len(DMA卖券还款底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index7,row7 in DMA卖券还款样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    updTime=datetime.datetime.now().strftime("%H:%M:%S.%f")
                    priceType=random.choice(DMAPriceType.split("&"))

                    for i in range(DMASplit):
                        价格指令=生成DMA价格指令(row7["证券代码"],"卖出")
                        custBatchNo=custBatchNo+1
                        DMA卖券还款指令记录=[updTime,custBatchNo,账号类型,资金账号,row7["证券代码"],"D",每手取整(row7["证券代码"],row7["卖券还款可用数"],DMASellRate),"DMA",priceType,价格指令[0],价格指令[1],价格指令[2]]
                        DMA卖券还款指令=pd.DataFrame([DMA卖券还款指令记录])
                        DMA卖券还款指令.columns=["updTime","custBatchNo","acctType","acct","symbol","tradeSide","targetQty","algoId","priceType","ticks","highLimitPrice","lowLimitPrice"]
                        DMA导入模板=pd.concat([DMA导入模板,DMA卖券还款指令])


            # 处理融券卖出算法模板
            DMA融券卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["融券可用头寸"]>0)]
            if len(DMA融券卖出底仓)==0 and 账号类型  in ["UFC","UMC","ATC"] :
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，融券卖出没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    DMA融券卖出执行数=int(交易标的总数/sloBase+1)*sloSellBase
                    log.info(f"DMA融券卖出算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA融券卖出执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融券卖出，不生成对应模板")
                    continue
                DMA融券卖出样本=DMA融券卖出底仓.sample(min(DMA融券卖出执行数,len(DMA融券卖出底仓)))
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index8,row8 in DMA融券卖出样本.iterrows():
                    updTime=datetime.datetime.now().strftime("%H:%M:%S.%f")
                    priceType=random.choice(DMAPriceType.split("&"))

                    for i in range(DMASplit):
                        价格指令=生成DMA价格指令(row8["证券代码"],"融券卖出")
                        custBatchNo=custBatchNo+1
                        DMA融券卖出指令记录=[updTime,custBatchNo,账号类型,资金账号,row8["证券代码"],"B",min(每手取整(row8["证券代码"],row8["融券可用头寸"],DMASellRate),1000),"DMA",priceType,价格指令[0],价格指令[1],价格指令[2]]
                        DMA融券卖出指令=pd.DataFrame([DMA融券卖出指令记录])
                        DMA融券卖出指令.columns=["updTime","custBatchNo","acctType","acct","symbol","tradeSide","targetQty","algoId","priceType","ticks","highLimitPrice","lowLimitPrice"]
                        DMA导入模板=pd.concat([DMA导入模板,DMA融券卖出指令])


            # 处理买券还券算法模板
            DMA买券还券底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["未还融券数量"]>0)]
            if len(DMA买券还券底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，买券还券没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    DMA买券还券执行数=int(交易标的总数/sloBase+1)*sloBuyBase
                    log.info(f"DMA买券还券算法模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{DMA买券还券执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持买券还券，不生成对应模板")
                    continue
                DMA买券还券样本=DMA买券还券底仓.sample(min(DMA买券还券执行数,len(DMA买券还券底仓)))
            if 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index9,row9 in DMA买券还券样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    updTime=datetime.datetime.now().strftime("%H:%M:%S.%f")
                    priceType=random.choice(DMAPriceType.split("&"))

                    for i in range(DMASplit):
                        价格指令=生成DMA价格指令(row9["证券代码"],"买入")
                        custBatchNo=custBatchNo+1
                        DMA买券还券指令记录=[updTime,custBatchNo,账号类型,资金账号,row9["证券代码"],"C",每手取整(row9["证券代码"],row9["未还融券数量"],1/DMASplit),"DMA",priceType,价格指令[0],价格指令[1],价格指令[2]]
                        DMA买券还券指令=pd.DataFrame([DMA买券还券指令记录])
                        DMA买券还券指令.columns=["updTime","custBatchNo","acctType","acct","symbol","tradeSide","targetQty","algoId","priceType","ticks","highLimitPrice","lowLimitPrice"]
                        DMA导入模板=pd.concat([DMA导入模板,DMA买券还券指令])



        log.info(f"资金账号：{资金账号}-DMA-algoOrder模板已导出")


        print(f"准备写入{len(DMA导入模板)}笔DMA母单")

        i=0
        init_order_cancel_files()  #初始化下单文件
        for index,row in DMA导入模板.iterrows():
            time.sleep(round(order_mm/1000,4))
            i=i+1
            DMAORDER=row.values.tolist()
            order_dma(DMAORDER,i)
        是否生成DMA扫单=True



    elif row["菜单"]=="算法单导入":
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成算法单导入模板：{资金账号}】")
        账号类型=row["账号类型"]
        汇总算法类型=row["子策略"]
        交易标的总数=int(row["深市主板"])+int(row["深市可转债"])+int(row["深市创业板"])+int(row["深市ETF基金"])+int(row["沪市主板"])+int(row["沪市可转债"])+int(row["沪市ETF基金"])+int(row["沪市科创板"]+int(row["北交所股票"]))
        算法单导入模板=pd.DataFrame(columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"])
        for 证券分类 in ["深市主板","深市可转债","深市创业板","深市ETF基金","沪市主板","沪市可转债","沪市ETF基金","沪市科创板","北交所股票"]:
            # 处理普通卖出算法模板
            交易可用普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(交易可用普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                普通卖出执行数=0
            else:
                if 账号类型  not in["UFC","UMC","ATC"]:
                    普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                else:
                    普通卖出执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*(1-buyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                普通卖出样本=交易可用普通卖出底仓.sample(min(普通卖出执行数,len(交易可用普通卖出底仓)))
            log.info(f"普通卖出算法单导入模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{普通卖出执行数}")
            if len(交易可用普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=min(普通卖出执行数,len(交易可用普通卖出底仓))
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                custAlgoNo=int(篮子ID[6:])
                for index1,row1 in 普通卖出样本.iterrows():
                    custAlgoNo=custAlgoNo+1
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    算法类型=random.choice(汇总算法类型.split(";"))
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="

                    算法单导入普通卖出指令记录=[datetime.datetime.now().strftime('%H%M%S.%f')[:-3],custAlgoNo,账号类型,资金账号,row1["证券代码"],"2",str(每手取整(row1["证券代码"],row1["普通卖出可用数"],maxEable)),"0",算法类型,算法参数]

                    算法单导入普通卖出指令=pd.DataFrame([算法单导入普通卖出指令记录])
                    算法单导入普通卖出指令.columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"]
                    算法单导入模板=pd.concat([算法单导入模板,算法单导入普通卖出指令])

            # 处理普通买入算法模板
            if 账号类型  not in["UFC","UMC","ATC"]:
                普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]-普通卖出执行数,miniNum))
            else:
                普通买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*(1-marginRate)*buyRate,miniNum))
            log.info(f"普通买入算法单导入模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{普通买入执行数}")
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                # 从全码表随机抽取代码
                母单序号=普通买入执行数
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)

                custAlgoNo=int(篮子ID[6:])
                for i in range(普通买入执行数):
                    custAlgoNo=custAlgoNo+1
                    # 生成买入算法单导入指令
                    普通买入证券代码=random.choice(全量码表[全量码表["证券分类"]==证券分类]["代码"].tolist())
                    算法类型=random.choice(汇总算法类型.split(";"))
                    # 根据不同算法，生成算法参数
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法单导入普通买入指令记录=[datetime.datetime.now().strftime('%H%M%S.%f')[:-3],custAlgoNo,账号类型,资金账号,普通买入证券代码,"1",str(random.randint(1,100)*200),"0",算法类型,算法参数]
                    算法单导入普通买入指令=pd.DataFrame([算法单导入普通买入指令记录])
                    算法单导入普通买入指令.columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"]
                    算法单导入模板=pd.concat([算法单导入模板,算法单导入普通买入指令])

            # 处理融资买入算法模板
            if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"] and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                融资买入执行数=int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*finBuyRate,miniNum))
                log.info(f"融资买入算法单导入模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{融资买入执行数}")
                # 从全码表随机抽取代码
                母单序号=融资买入执行数
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                custAlgoNo=int(篮子ID[6:])
                for i in range(融资买入执行数):
                    custAlgoNo=custAlgoNo+1
                    # 生成融资买入算法单导入指令
                    融资买入证券代码=random.choice(融资标的[融资标的["证券分类"]==证券分类]["strSecurityID"].tolist())
                    算法类型=random.choice(汇总算法类型.split(";"))
                    # 根据不同算法，生成算法参数
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法单导入融资买入指令记录=[datetime.datetime.now().strftime('%H%M%S.%f')[:-3],custAlgoNo,账号类型,资金账号,融资买入证券代码,"A",str(random.randint(1,100)*200),"0",算法类型,算法参数]
                    算法单导入融资买入指令=pd.DataFrame([算法单导入融资买入指令记录])
                    算法单导入融资买入指令.columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"]
                    算法单导入模板=pd.concat([算法单导入模板,算法单导入融资买入指令])
            else:
                # 信用户特殊处理可转债
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融资买入，不生成对应模板")
                continue



            # 处理卖券还款算法模板
            交易可用卖券还款底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["卖券还款可用数"]>0)]
            if len(交易可用卖券还款底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，卖券还款没有底仓，不生成对应模板")
                卖券还款执行数=0
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    卖券还款执行数=min(int(max(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]*marginRate*(1-finBuyRate),miniNum)),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["卖券还款"].iloc[0])
                    log.info(f"卖券还款算法单导入模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{卖券还款执行数}")
                else:
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持卖券还款，不生成对应模板")
                    continue
                卖券还款样本=交易可用卖券还款底仓.sample(min(卖券还款执行数,len(交易可用卖券还款底仓)))
            if len(交易可用卖券还款底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=min(卖券还款执行数,len(交易可用卖券还款底仓))
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                custAlgoNo=int(篮子ID[6:])
                for index2,row2 in 卖券还款样本.iterrows():
                    custAlgoNo=custAlgoNo+1
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    算法类型=random.choice(汇总算法类型.split(";"))
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法单导入卖券还款指令记录=[datetime.datetime.now().strftime('%H%M%S.%f')[:-3],custAlgoNo,账号类型,资金账号,row2["证券代码"],"D",str(每手取整(row2["证券代码"],row2["卖券还款可用数"],maxEable)),"0",算法类型,算法参数]
                    算法单导入卖券还款指令=pd.DataFrame([算法单导入卖券还款指令记录])
                    算法单导入卖券还款指令.columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"]
                    算法单导入模板=pd.concat([算法单导入模板,算法单导入卖券还款指令])

            # 处理融券卖出算法模板
            交易可用融券卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["融券可用头寸"]>0)]
            if len(交易可用融券卖出底仓)==0 and 账号类型  in ["UFC","UMC","ATC"] :
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，融券卖出没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    融券卖出执行数=int(交易标的总数/sloBase+1)*sloSellBase
                    log.info(f"融券卖出算法单导入模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{融券卖出执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持融券卖出，不生成对应模板")
                    continue
                融券卖出样本=交易可用融券卖出底仓.sample(min(融券卖出执行数,len(交易可用融券卖出底仓)))
            if  任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=min(融券卖出执行数,len(交易可用融券卖出底仓))
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                custAlgoNo=int(篮子ID[6:])
                for index3,row3 in 融券卖出样本.iterrows():
                    custAlgoNo=custAlgoNo+1
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    算法类型=random.choice(汇总算法类型.split(";"))
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法单导入融券卖出指令记录=[datetime.datetime.now().strftime('%H%M%S.%f')[:-3],custAlgoNo,账号类型,资金账号,row3["证券代码"],"B",str(min(每手取整(row3["证券代码"],row3["融券可用头寸"],maxEable),2000)),"0",算法类型,算法参数]
                    算法单导入融券卖出指令=pd.DataFrame([算法单导入融券卖出指令记录])
                    算法单导入融券卖出指令.columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"]
                    算法单导入模板=pd.concat([算法单导入模板,算法单导入融券卖出指令])


            # 处理买券还券算法模板

            交易可用买券还券底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["未还融券数量"]>0)]
            if len(交易可用买券还券底仓)==0 and 账号类型  in ["UFC","UMC","ATC"]:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，买券还券没有底仓，不生成对应模板")
                continue
            else:
                if 账号类型   in ["UFC","UMC","ATC"] and 证券分类 not in ["深市可转债","沪市可转债"]:
                    买券还券执行数=int(交易标的总数/sloBase+1)*sloBuyBase
                    log.info(f"买券还券算法单导入模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{买券还券执行数}")
                else :
                    # 信用户可转债不处理
                    log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，不支持买券还券，不生成对应模板")
                    continue
                买券还券样本=交易可用买券还券底仓.sample(min(买券还券执行数,len(交易可用买券还券底仓)))
            if 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                母单序号=min(买券还券执行数,len(交易可用买券还券底仓))
                now = datetime.datetime.now()
                篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
                跃然结束时间=random.choice(随机算法结束时间)
                custAlgoNo=int(篮子ID[6:])
                for index4,row4 in 买券还券样本.iterrows():
                    custAlgoNo=custAlgoNo+1
                    算法类型=random.choice(汇总算法类型.split(";"))
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    if 算法类型=="QND-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型=="QND-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";allowTradeAtLimit=0;allowTradeAfterEnd=0;custBatchNo="
                    elif 算法类型 in ["FT-WAP","SMOOTH"]:
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)
                    elif 算法类型=="KF-POV":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;maxpercentageF=0.20;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=1;afterAction=1;custBatchNo="
                    elif 算法类型=="KF-VWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-PLUS":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="KF-TWAP-CORE":
                        算法参数="beginTime=093000;endTime="+random.choice(随机算法结束时间)+";priceF=0;UpLimitF=0.2;DownLimitF=0.2;limitAction=0;afterAction=0;custBatchNo="
                    elif 算法类型=="OQ-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.15;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="OQ-POV":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0.05;minAmount=0;tradingStyle=2;notBuyOnLLAndSellOnHL=0;custBatchNo="
                    elif 算法类型=="XT-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.20;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="XT-VP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;PartRate=0.05;MinAmount=0;m_nStopTradeForOwnHiLow=0;custBatchNo="
                    elif 算法类型=="YR-VWAP":
                        算法参数="beginTime=93000;endTime="+跃然结束时间+";limitRule=0"+";basketId="+篮子ID+";basketSize="+str(母单序号)
                    elif 算法类型=="HX-SMART-TWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";limitPrice=0;participateRate=0;notBuyOnLLAndSellOnHL=1;custBatchNo="
                    elif 算法类型=="HX-SMART-TWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    elif 算法类型=="HX-SMART-VWAP-BUS":
                        算法参数="beginTime=93000;endTime="+random.choice(随机算法结束时间)+";priceF=0;participateRate=0;limitAction=0;custBatchNo="
                    算法单导入买券还券指令记录=[datetime.datetime.now().strftime('%H%M%S.%f')[:-3],custAlgoNo,账号类型,资金账号,row4["证券代码"],"C",每手取整(row4["证券代码"],row4["未还融券数量"],maxEable),"0",算法类型,算法参数]
                    算法单导入买券还券指令=pd.DataFrame([算法单导入买券还券指令记录])
                    算法单导入买券还券指令.columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"]
                    算法单导入模板=pd.concat([算法单导入模板,算法单导入买券还券指令])
        saveCsvByTime("Stock_Algo"+str(资金账号)+"_"+str(账号类型),算法单导入模板,True,"ANSI","outPut")
        log.info(f"资金账号：{资金账号}ALGO-STOCK导入模板已导出")

        print(f"准备写入{len(算法单导入模板)}笔算法单母单")

        i=0
        init_algoorder_cancel_files()  #初始化下单文件
        for index,row in 算法单导入模板.iterrows():
            time.sleep(round(order_mm/1000,4))
            i=i+1
            DMAORDER=row.values.tolist()
            order_algo(DMAORDER,i)

        是否生成算法单扫单=True
    elif row["菜单"]=="算法单导入-T0":
        导出算法单导入T0标识=True
        资金账号=row["账号"]
        log.info(f"【该资金账号开始生成算法单导入T0模板：{资金账号}】")
        账号类型=row["账号类型"]
        算法类型=row["子策略"]
        交易标的总数=int(row["深市主板"])+int(row["深市创业板"])+int(row["沪市主板"])+int(row["沪市科创板"]+int(row["北交所股票"]))
        T0明细="securities="
        T0持仓市值=0
        now = datetime.datetime.now()
        篮子ID="M"+now.strftime("%H:%M:%S.%f").replace(":","").replace(".","")
        跃然结束时间=random.choice(随机算法结束时间)
        custAlgoNo=int(篮子ID[6:])
        for 证券分类 in ["深市主板","深市创业板","沪市主板","沪市科创板","北交所股票"]:
            # 处理普通卖出算法模板
            交易可用普通卖出底仓=交易可用清单[(交易可用清单["账号"]==资金账号) &(交易可用清单["证券分类"]==证券分类) & (交易可用清单["普通卖出可用数"]>0)]
            if len(交易可用普通卖出底仓)==0:
                log.info(f"{资金账号}、账号类型：{账号类型}、{证券分类}，普通卖出没有底仓，不生成对应模板")
                普通卖出执行数=0
            else:
                if 账号类型  not in["UFC","UMC","ATC"]:
                    普通卖出执行数=min(int(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                else:
                    普通卖出执行数=min(int(任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]),资金账号品种可用汇总[(资金账号品种可用汇总["账号"]==资金账号)&(资金账号品种可用汇总["证券分类"]==证券分类)]["普通卖出"].iloc[0])
                普通卖出样本=交易可用普通卖出底仓.sample(min(普通卖出执行数,len(交易可用普通卖出底仓)))
            log.info(f"算法单导入T0模板开始生成：{资金账号}、账号类型：{账号类型}、证券分类：{证券分类}，执行记录数：{普通卖出执行数}")
            if len(交易可用普通卖出底仓)!=0 and 任务配置列表[任务配置列表["账号"]==资金账号][证券分类].iloc[0]!=0:
                for index1,row1 in 普通卖出样本.iterrows():
                    # 根据不同算法，生成算法参数，随机生成结束时间
                    T0底仓数量=每手取整(row1["证券代码"],row1["普通卖出可用数"],T0Max)
                    T0代码=row1["证券代码"]
                    新增T0明细=f"{T0代码}&"+f"{str(T0底仓数量)}|"
                    T0明细=T0明细+新增T0明细
                    T0持仓市值=T0持仓市值+T0底仓数量*tencentQuo(T0代码,"now")
        T0明细=T0明细[:-1]
        底仓T0授权资金=round(T0持仓市值*0.1,2)
        算法参数=f"beginTime=93000;endTime={跃然结束时间};capital={底仓T0授权资金};buyType=0;sellType=0;{T0明细}"
        算法单导入T0指令记录=[datetime.datetime.now().strftime('%H%M%S.%f')[:-3],custAlgoNo,账号类型,资金账号,"0","0","0","0",算法类型,算法参数]

        算法单导入T0指令=pd.DataFrame([算法单导入T0指令记录])
        算法单导入T0指令.columns=["updTime","custAlgoNo","acctType","acct","symbol","tradeSide","targetQty","targetAmt","algoId","algoParam"]
        算法单导入T0模板=pd.concat([算法单导入T0模板,算法单导入T0指令])



    else:
        生成菜单=row["菜单"]
        log.info(f"还不支持此菜单:{生成菜单}生成模板")
# 导出各个菜单的模板

if  导出算法交易标识==True:
    saveCsvByTime("算法交易手工导入模板",算法交易导入模板,True,"ANSI","outPut")
    log.info("算法交易导入模板已导出")
if  导出网格交易标识==True:
    saveCsvByTime("网格交易手工导入模板",网格交易导入模板,True,"ANSI","outPut")
    log.info("网格交易导入模板已导出")
if  导出组合交易标识==True:
    # 去除重复数据
    组合交易导入模板.drop_duplicates(subset=["账户","代码","买卖方向"],keep='first',inplace=True)
    saveCsvByTime("组合交易手工导入模板",组合交易导入模板,True,"ANSI","outPut")
    log.info("组合交易导入模板已导出")
if  导出价差策略标识==True:
    saveCsvByTime("价差策略手工导入模板",价差策略导入模板,True,"ANSI","outPut")
    log.info("价差策略导入模板已导出")

if  导出算法单导入T0标识==True:
    saveCsvByTime("算法单导入T0模板",算法单导入T0模板,True,"ANSI","outPut")
    log.info("算法单导入T0模板已导出")



log.info("全部导入模板已经生成")

DMA任务配置列表=任务配置列表[(任务配置列表["启用"]=="Y") &(任务配置列表["菜单"]=="DMA算法")]
算法单导入任务配置列表=任务配置列表[(任务配置列表["启用"]=="Y") &(任务配置列表["菜单"]=="算法单导入")]
if len(DMA任务配置列表)>0 and 是否生成DMA扫单==True:
    print("开始判断algoOrder跟execResult时序")
    判断时序是否一致()
if len(算法单导入任务配置列表)>0 and 是否生成算法单扫单==True:
    print("开始判断算法单导入：algoStart跟algoExecStatic时序")
    判断algo时序是否一致()

print("开始判断委托明细和成交明细执行情况")
# 统计交易下单联通性()


input("Press Enter to exit…")
#







